In `@apps/backend/core/platform/__init__.py`:
- Around line 519-535: The get_windows_system_path function duplicates
case-insensitive env lookup; replace the manual
os.environ.get("PATH")/("Path")/("path") logic by calling the existing helper
get_env_var("PATH") so behavior is centralized; update the return to use
get_env_var("PATH") inside get_windows_system_path and keep the early
is_windows() check intact.

In `@apps/frontend/src/main/env-utils.ts`:
- Around line 111-127: COMMON_BIN_PATHS currently contains hardcoded Windows
roots; replace those literals by constructing Windows paths from environment
variables and platform helpers: when process.platform === 'win32', read
ProgramFiles, ProgramFiles(x86) (or fallback to ProgramFiles), ProgramData,
SystemRoot, LOCALAPPDATA, APPDATA and USERPROFILE, use path.join or path.resolve
to build the specific subpaths (e.g. join(ProgramFiles, 'Git', 'cmd'),
join(ProgramFiles, 'nodejs'), join(LOCALAPPDATA, 'Programs', 'nodejs'),
join(APPDATA, 'npm'), join(USERPROFILE, '.local', 'bin'), join(ProgramData,
'chocolatey', 'bin'), etc.), expand '~' against USERPROFILE for POSIX-style
entries, filter out undefined or non-existent env values, and only include these
constructed entries in COMMON_BIN_PATHS so platform-specific roots are not
hardcoded.

In `@apps/frontend/src/renderer/components/terminal/useXterm.ts`:
- Around line 333-372: Guard against window.matchMedia being undefined and add a
resize fallback, then re-register the media query whenever DPI changes: inside
the effect, check if window.matchMedia exists before using it and fall back to
listening to window.resize; modify the handleDPIChange routine (and its
debounce) to, after adjusting xtermRef.current.options.fontSize and calling
fitAddonRef.current.fit() (using terminalRef to check bounds), recreate the
mediaQuery using the latest window.devicePixelRatio and reattach its 'change'
listener so the query isn't stale; ensure you remove the correct listeners on
cleanup (use removeEventListener when added and removeListener fallback for
older APIs) and reference the existing symbols handleDPIChange, xtermRef,
fitAddonRef, terminalRef, and mediaQuery when updating the logic.

In `@apps/frontend/src/renderer/components/terminal/useXterm.ts`:
- Around line 383-399: Guard against window.matchMedia being undefined and make
the DPI listener re-register the media query after DPI changes: in the effect
that creates mediaQuery (the variable mediaQuery) check if typeof
window.matchMedia === 'function' before using it and return early if not (or add
the provided JSDOM mock in test setup to unblock CI); modify handleDPIChange so
it removes listeners from the existing mediaQuery, recomputes a new mediaQuery
using the current window.devicePixelRatio, and attaches the appropriate listener
via addEventListener/addListener (and corresponding
removeEventListener/removeListener) so subsequent DPI changes (e.g., moving
between monitors) are detected; ensure cleanup returns a function that removes
listeners from whichever mediaQuery is currently registered.

In `@apps/frontend/src/main/memory-service.ts`:
- Around line 779-784: The code uses a dynamic require to get spawnSync; replace
that with a static import at the top of the module alongside spawn from
'child_process' and remove the require call where spawnSync is used (the block
that currently declares const { spawnSync } = require('child_process'); and then
calls spawnSync). Update imports to statically import { spawn, spawnSync } from
'child_process' so both symbols are available for the code that calls
spawnSync(cmd, checkArgs, ...).

In
`@apps/frontend/src/main/terminal/__tests__/claude-integration-handler.test.ts`:
- Around line 646-691: Add a Linux-specific unit test to the escapeShellCommand
suite: inside the existing describe('escapeShellCommand') block add a test that
calls mockPlatform('linux'), imports escapeShellCommand from
../claude-integration-handler, calls escapeShellCommand('/usr/local/bin/claude')
and asserts the result equals "'/usr/local/bin/claude'"; this mirrors the macOS
(darwin) case and ensures Linux coverage alongside Windows and macOS.

In `@apps/frontend/src/main/terminal/claude-integration-handler.ts`:
- Around line 97-120: The PowerShell branch in escapeShellCommand should use
PowerShell-safe single-quote quoting instead of escapeForWindowsDoubleQuote:
when isWindows() and shellType === 'powershell', produce a single-quoted string
(handle embedded single quotes by doubling them) and prefix with the call
operator (&) so the result is & '...'; do not apply cmd.exe-specific percent (%)
escaping or double-quote escaping (escapeForWindowsDoubleQuote) in this
branch—leave escapeForWindowsDoubleQuote for the cmd.exe branch only.

In `@apps/frontend/src/renderer/components/project-settings/SecuritySettings.tsx`:
- Around line 57-76: Extract the duplicated memoriesDir state and fetch logic
into a reusable hook (e.g., useMemoriesDir) and replace the local
useState/useEffect in SecuritySettings, MemoryBackendSection, and MemoriesTab
with that hook; specifically, move the window.electronAPI.getMemoriesDir() call
and the setMemoriesDir updater into the new useMemoriesDir hook and have it
return the memoriesDir string, then in the components remove the local
memoriesDir/setMemoriesDir and import/use useMemoriesDir() where the current
memoriesDir variable is referenced.

In `@apps/frontend/src/main/memory-service.ts`:
- Around line 747-828: The checkLadybugInstalled function currently calls
spawnSync without the Python environment and uses hardcoded user-facing strings;
update the spawnSync call in checkLadybugInstalled to include the env option set
to getMemoryPythonEnv() (same pattern as other spawn() calls) so PYTHONPATH is
correct, and replace all hardcoded error/user messages returned via
ladybugInstallCache (e.g., the "Python not found..." message and the messages
set when ModuleNotFoundError/WinError2/other failures occur) to use i18n
translation keys (e.g., errors:ladybug.pythonNotFound,
errors:ladybug.notInstalled, errors:ladybug.buildTools,
errors:ladybug.checkFailed) with interpolation where needed; keep
ladybugInstallCache and clearLadybugInstallCache untouched otherwise.

In `@apps/frontend/src/main/terminal/claude-integration-handler.ts`:
- Around line 180-208: The command builders mix cmd.exe and PowerShell syntax;
update buildPathPrefix and buildClaudeShellCommand to accept shellType
(propagate terminal.shellType through call sites) and branch on it: when
shellType === 'powershell' emit PowerShell forms (e.g., use $env:PATH=...; use
';' separators, use & '<cmd>' to invoke, and Remove-Item for deletions) and when
not Windows or cmd.exe keep existing cmd.exe forms (set "PATH=..." &&, call,
del, &&); also update generateTokenTempFileContent to produce
PowerShell-compatible temp-file content when shellType === 'powershell' and
ensure escapeShellCommand is used consistently with the passed shellType.

In `@apps/frontend/src/renderer/components/context/MemoriesTab.tsx`:
- Around line 162-164: Replace hardcoded user strings in the MemoriesTab
component by importing and using useTranslation and translation keys: call const
{ t } = useTranslation() and change InfoItem label props ("Database", "Path")
and fallback values (memoriesDir fallback 'memories directory' and
memoryStatus.database fallback 'auto_claude_memory') to t('memory.database'),
t('memory.path'), t('memory.fallbacks.auto_claude_memory'), and
t('memory.fallbacks.memories_directory') (or similar keys you add). Also replace
the error string "Graphiti memory is not configured" with
t('memory.errors.graphiti_not_configured'). Add those keys to your translation
JSON (e.g., common.json or memory.json) for all supported locales. Ensure
InfoItem and any render branches reference the translated strings via t(...)
instead of hardcoded text.

In `@apps/frontend/src/renderer/components/onboarding/GraphitiStep.tsx`:
- Around line 828-859: Replace the three hardcoded strings in the LadybugDB
status block inside the GraphitiStep component (the JSX guarded by
ladybugInstalled === false && ladybugError) with i18n translation keys using the
react-i18next t function: import and use the useTranslation hook (e.g., const {
t } = useTranslation()) and change "LadybugDB Not Installed", "Download Visual
Studio Build Tools", and "After installing build tools, restart the application
to retry." to t('onboarding.ladybug.notInstalled'),
t('onboarding.ladybug.downloadBuildTools'), and
t('onboarding.ladybug.restartAfterInstall') (or your project's key naming
convention), respectively; keep the conditional that shows the external link
when ladybugError.includes('Visual Studio Build Tools') intact so only the
visible strings are replaced with translation keys.
- Around line 176-181: The catch block that currently only sets
setKuzuAvailable(false) and setLadybugInstalled(false) should also set a generic
error message via setLadybugError(...) so the UI warning card (which checks
ladybugInstalled === false && ladybugError) displays on failures of
getMemoryInfrastructureStatus; update the catch in the infra-check logic (where
getMemoryInfrastructureStatus is called and setKuzuAvailable/setLadybugInstalled
are used) to call setLadybugError with a concise user-facing message and ensure
setLadybugInstalled(false) remains set, leaving setIsCheckingInfra(false) in
finally.

In `@apps/frontend/src/renderer/components/terminal/useXterm.ts`:
- Around line 49-65: Extract the DPI-adjusted font size logic into a single
helper function (e.g., getAdjustedFontSize(baseFontSize = 13)) and replace the
duplicated calculations in both the XTerm initialization (where adjustedFontSize
is currently computed before new XTerm({... fontSize:
Math.round(adjustedFontSize) ...})) and the handleDPIChange handler (the
duplicate sqrt-based scaling and min 11px logic) to call this helper and use
Math.round on its result; ensure the helper uses window.devicePixelRatio || 1,
applies 1 / Math.sqrt(scaleFactor) when scaleFactor > 1, enforces a minimum of
11, and is imported/defined in the same module so both initialization and
handleDPIChange call the single function.

In `@apps/frontend/src/main/memory-service.ts`:
- Around line 770-828: In checkLadybugInstalled, after calling spawnSync (the
variable result), add an explicit check for result.error and handle spawn
failures before inspecting result.status/stdout: if result.error.code ===
'ENOENT' set ladybugInstallCache to installed: false, pythonAvailable: false and
error: LADYBUG_ERROR_KEYS.pythonNotFound; for other errors (including timeouts)
set installed: false, pythonAvailable: true and error:
LADYBUG_ERROR_KEYS.checkFailed (or a new error key if preferred); ensure this
check runs before the existing result.status === 0 branch so missing executables
and spawn failures aren’t misclassified as “not installed.” Use the existing
symbols (spawnSync result, LADYBUG_ERROR_KEYS, ladybugInstallCache,
parsePythonCommand, getMemoryPythonEnv) to locate and update the logic.

In `@apps/frontend/src/renderer/components/onboarding/GraphitiStep.tsx`:
- Around line 146-166: The useEffect that calls
window.electronAPI.getMemoriesDir can call setMemoriesDir after the component
unmounts; add a mounted flag inside that useEffect (e.g., let isMounted = true;
and a cleanup that sets it false) and only call setMemoriesDir or
setMemoriesDir-related state when isMounted is true; keep the existing
result.success/data checks and ensure the .catch handler also checks isMounted
before touching state or logging if needed.
- Around line 996-998: Replace the hardcoded fallback text for the memories
directory in the GraphitiStep component: change the paragraph rendering that
uses memoriesDir || 'memories directory' to use i18n keys and interpolation (use
the t function with keys onboarding:memory.storedIn and
onboarding:memory.defaultDir, passing memoriesDir as the interpolated value).
Also add the new keys onboarding:memory.storedIn and
onboarding:memory.defaultDir to the en/onboarding.json and fr/onboarding.json
translation files so the component can render a localized message when
memoriesDir is absent.
- Around line 173-181: The code currently reads memory fields without verifying
result.success, causing result.error to be ignored; update the block that calls
window.electronAPI.getMemoryInfrastructureStatus() so you first check
result?.success before accessing result.data: only extract memory and call
setKuzuAvailable/setLadybugInstalled/setLadybugError from memory when
result.success is true, otherwise setKuzuAvailable(false),
setLadybugInstalled(false) and setLadybugError(result?.error ??
t('onboarding:ladybug.checkFailed')); ensure setLadybugError is also populated
in the existing catch block for thrown exceptions.

In `@apps/frontend/src/renderer/components/terminal/useXterm.ts`:
- Around line 383-454: The debounced handlers (created for handleResize and
handleDPIChange inside the useEffect) should be cancelled on cleanup to avoid
pending invocations after unmount; capture the debounced functions in variables
(e.g., handleResize and handleDPIChange as returned by debounce), and in the
effect cleanup call their cancel() method (or clear the timer if using a custom
debounce) before removing listeners and tearing down currentMediaQuery; ensure
registerDPIListener and currentMediaQuery logic still removes listeners as-is
and that you cancel the debounce for both the test fallback resize handler and
the DPI-change handler created in this effect.

In `@apps/frontend/src/shared/i18n/locales/en/memory.json`:
- Around line 1-10: These translation keys in memory.json must be moved into
approved namespaces: relocate "database", "path" and the "fallbacks" entries
("auto_claude_memory", "memories_directory") into settings.json under a new
"memory" section (e.g., settings:memory.database, settings:memory.path,
settings:memory.fallbacks.auto_claude_memory,
settings:memory.fallbacks.memories_directory), move the error
"graphiti_not_configured" into errors.json (errors:graphiti_not_configured),
update any code that imports or references the old keys to use the new
namespaced keys, and remove the unused memory.json file.

In `@apps/frontend/src/renderer/hooks/useMemoriesDir.ts`:
- Around line 10-20: The effect in useMemoriesDir can call setMemoriesDir after
unmount; add a mounted flag inside the useEffect (e.g., let mounted = true) and
in the promise handlers check mounted before calling setMemoriesDir or logging
errors, then set mounted = false in the effect cleanup so no state updates occur
after unmount; reference useEffect, window.electronAPI.getMemoriesDir, and
setMemoriesDir when locating where to add the mounted guard and cleanup.

In `@apps/frontend/src/main/memory-service.ts`:
- Around line 770-844: checkLadybugInstalled currently does a blocking spawnSync
(with timeout) and is invoked synchronously from getMemoryServiceStatus via the
MEMORY_STATUS IPC handler, which can freeze the UI on first call; change the
flow so the heavyweight Python check runs asynchronously off the IPC critical
path: convert checkLadybugInstalled to an async function that uses
child_process.spawn (or spawn wrapped in a Promise) instead of spawnSync, update
getMemoryServiceStatus to call the async check non-blockingly (await only when
safe or return a cached/initial "checking" status and kick off the async check
to populate ladybugInstallCache), and ensure error/caching logic in
checkLadybugInstalled (and the exported symbol used by IPC) remains identical
(keep LADYBUG_ERROR_KEYS handling and parsing of stdout/stderr) so callers can
rely on the same cache shape.

In `@apps/frontend/src/main/ipc-handlers/memory-handlers.ts`:
- Around line 416-428: The handler registered on ipcMain.handle for
IPC_CHANNELS.MEMORY_GET_DIR (the async function that calls getDefaultDbPath)
returns a hardcoded user-facing string on error; change that to return the i18n
translation key (e.g., "errors:memory.getDirFailed") instead of 'Failed to get
memories directory' so the renderer can localize messages—update the error
return in the catch block to use the translation key while preserving the
existing Error type check (error instanceof Error ? error.message :
'errors:memory.getDirFailed') or otherwise ensure the returned error field is
the i18n key.

In `@apps/frontend/src/main/memory-service.ts`:
- Line 615: Replace the hardcoded user-facing string assigned to message
(currently using path.join(data.databasePath, data.database)) with an i18n
translation key; call the app's i18n translate function to produce the message
using the key "errors:memory.databaseNotFound" and pass the interpolated path
(path.join(data.databasePath, data.database)) as a parameter so the message
becomes i18n.t('errors:memory.databaseNotFound', { path:
path.join(data.databasePath, data.database) }) instead of the literal string.
- Around line 891-914: The sync wrapper checkLadybugInstalled() currently
returns pythonAvailable: true while the async probe runs, which can mislead
legacy sync callers; before returning the temporary "checking" status, call the
local findPythonCommand() (or equivalent helper used elsewhere) and if it
indicates Python is not present, return { installed: false, pythonAvailable:
false } immediately; still kick off checkLadybugInstalledAsync() in the
background as before, and ensure you reference and use findPythonCommand(),
checkLadybugInstalled(), and checkLadybugInstalledAsync() so callers get an
accurate short‑circuit result without changing the async behavior.

In `@apps/frontend/src/shared/i18n/locales/en/errors.json`:
- Line 2: The error locale key uses snake_case ("graphiti_not_configured") while
other keys use camelCase; rename the key to camelCase ("graphitiNotConfigured")
in the locales JSON and update every code reference that reads this locale key
(search for "graphiti_not_configured") to the new "graphitiNotConfigured"
identifier, ensuring consistency with existing keys like "pythonNotFound" and
"getDirFailed" and that any i18n lookup functions still resolve the renamed key.

In `@apps/frontend/src/shared/i18n/locales/en/onboarding.json`:
- Around line 111-118: The en onboarding JSON contains duplicate keys "storedIn"
and "defaultDir" (e.g., entries for "storedIn": "Stored in {{path}}" and
"defaultDir": "memories directory" appear twice); remove the duplicate entries
so each i18n key appears only once (keep the intended value for "storedIn" and
"defaultDir" and delete the redundant pair), and verify any other locale files
don't have the same duplicate to prevent silent overrides.

In `@apps/frontend/src/shared/i18n/locales/fr/errors.json`:
- Around line 19-20: Update the French translation string for the key
"memory.getDirFailed" to use the singular term consistent with the rest of the
UI (e.g., change "mémoires" to "mémoire"), ensuring the message matches the
singular phrasing used elsewhere like "mémoire Graphiti"; locate and edit the
"memory.getDirFailed" entry in the locales/fr/errors.json and replace the plural
noun so all memory-related keys use the singular form.

In `@apps/frontend/src/shared/i18n/locales/fr/onboarding.json`:
- Around line 111-118: The JSON contains duplicate keys storedIn and defaultDir
inside the memory object; remove the first occurrence of storedIn/"Stocké dans
{{path}}" and defaultDir/"répertoire de mémoires" and keep the later entries,
ensuring defaultDir uses "répertoire des mémoires" (the preferred translation)
so there are no duplicate keys and the memory object remains valid JSON.

In
`@apps/frontend/src/renderer/components/project-settings/MemoryBackendSection.tsx`:
- Around line 497-500: The fallback string "memories directory" is hardcoded in
the MemoryBackendSection component; replace both occurrences (the JSX text:
Custom storage location. Default: {memoriesDir || 'memories directory'} and the
Input placeholder prop placeholder={memoriesDir || 'memories directory'}) to use
the i18n key t('memory.fallbacks.memories_directory') as the fallback (e.g.,
memoriesDir || t('memory.fallbacks.memories_directory')), ensuring you
import/use the existing t function in that component.
- Line 485: The JSX currently hardcodes the fallback string 'memories
directory'; update MemoryBackendSection (component) to use i18n by importing
useTranslation, calling const { t } = useTranslation() at the top of the
component, and replace the hardcoded fallback (memoriesDir || 'memories
directory') with (memoriesDir || t('memory.fallbacks.memories_directory'));
ensure any other similar fallback occurrences in MemoryBackendSection use the
same t(...) key.

In `@apps/frontend/src/main/memory-service.ts`:
- Around line 793-810: Replace calls to findPythonCommand() with
getBackendPythonPath() when performing the real_ladybug import check so the
install probe uses the same backend venv resolver as memory queries; remove the
now-unnecessary null check around python command existence in the ladybug
install flow (the block that sets ladybugInstallCache when pythonCmd is falsy)
and always proceed to parsePythonCommand(getBackendPythonPath()) inside the
ladybugCheckInProgress promise (the area using parsePythonCommand, checkArgs and
pythonEnv/getMemoryPythonEnv()). Also update the status-reporting locations that
set pythonAvailable (previously using findPythonCommand()) to use
getBackendPythonPath() at the other two spots mentioned (the code around where
pythonAvailable is computed at the later status checks).

In
`@apps/frontend/src/renderer/components/project-settings/InfrastructureStatus.tsx`:
- Around line 29-63: InfrastructureStatus currently renders hardcoded
user-facing strings; update the component to import and call
useTranslation('settings') and replace all hardcoded labels (e.g., "LadybugDB",
"Installed", "Not Installed", "Download Visual Studio Build Tools", "Ready",
"Will be created on first use", "Requires LadybugDB", "Graph memory is ready to
use", "Graph memory requires Python 3.12+ with LadybugDB. No Docker needed.",
"Memory Infrastructure") with t('settings:memory.<key>') using the keys provided
in the review (memory.ladybug, memory.installed, memory.notInstalled,
memory.downloadBuildTools, memory.ready, memory.willBeCreatedOnFirstUse,
memory.requiresLadybug, memory.graphReadyToUse, memory.graphRequirement,
memory.infrastructureTitle) while preserving conditional logic around
ladybugInstalled and ladybugError and the external link; then add the same keys
under the memory section in the settings.json locale file so translations
resolve.