@memorax/memorax-code 0.1.4 → 0.1.6

package/lib/memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs

@@ -23,10 +23,11 @@ export async function runMemorySkillReminderHook(options, hookInput) {
     const result = await evaluateMemorySkillReminder(options, input);
     if (!result) return;
     process.stdout.write(`${JSON.stringify({
-      hookSpecificOutput: {
+      ...(result.systemMessage ? { systemMessage: result.systemMessage } : {}),
+      ...(result.additionalContext ? { hookSpecificOutput: {
         hookEventName: "UserPromptSubmit",
         additionalContext: result.additionalContext,
-      },
+      } } : {}),
     })}\n`);
     if (result.reminder) await notifyReminder(options, result.reminder);
   } catch (error) {
@@ -80,7 +81,8 @@ export async function evaluateMemorySkillReminder(options, input) {
     const { memoryReminderDue, supplementalReminderDue } = update;
 
     const baseAdditionalContext = stringOption(options.baseAdditionalContext);
-    if (!baseAdditionalContext && !memoryReminderDue && !supplementalReminderDue) return undefined;
+    const systemMessage = stringOption(options.systemMessage);
+    if (!baseAdditionalContext && !memoryReminderDue && !supplementalReminderDue && !systemMessage) return undefined;
     const cadenceReminderContext = memoryReminderDue
       ? await buildCadenceReminderContext(options, input)
       : undefined;
@@ -97,7 +99,8 @@ export async function evaluateMemorySkillReminder(options, input) {
       ...(supplementalReminderDue ? ["post_compaction"] : []),
     ];
     return {
-      additionalContext,
+      ...(systemMessage ? { systemMessage } : {}),
+      ...(additionalContext ? { additionalContext } : {}),
       ...(reminderContext ? {
         reminder: {
           sessionId,

package/lib/memorax-code-adapter-common/src/setup-completion.d.mts

@@ -0,0 +1,81 @@
+import type { JsonFileLockOptions } from "./config-utils.mjs";
+import {
+  RuntimeRecordError,
+  type RuntimeRecordWriteResult,
+  type RuntimeRecordWriteRuntime,
+} from "./runtime-record.mjs";
+
+export type SetupCompletionRecord = Readonly<{
+  version: 1;
+  state: "complete";
+  completedAt: string;
+  completedByVersion: string;
+}>;
+
+export type SetupCompletionRecordInvalidReason =
+  | "unreadable"
+  | "malformed_json"
+  | "invalid_record"
+  | "invalid_version"
+  | "unknown_fields"
+  | "invalid_state"
+  | "invalid_completed_at"
+  | "invalid_completed_by_version";
+
+export type SetupCompletionRecordState =
+  | Readonly<{ status: "absent" }>
+  | Readonly<{ status: "valid"; record: SetupCompletionRecord }>
+  | Readonly<{ status: "invalid"; reason: SetupCompletionRecordInvalidReason }>
+  | Readonly<{ status: "unsupported"; version: number }>;
+
+export type WritableSetupCompletionRecordState = Extract<
+  SetupCompletionRecordState,
+  { status: "absent" | "valid" }
+>;
+
+export type SetupCompletionClearResult = Readonly<{
+  path: string;
+  removed: boolean;
+}>;
+
+export type SetupCompletionLockMutation = Readonly<{
+  clear(): SetupCompletionClearResult;
+}>;
+
+export const SETUP_COMPLETION_RECORD_VERSION: 1;
+
+export class SetupCompletionRecordError extends RuntimeRecordError {
+  constructor(
+    state: Extract<SetupCompletionRecordState, { status: "invalid" | "unsupported" }>,
+    path: string,
+  );
+}
+
+export function setupCompletionPath(memoraxCodeHome?: string): string;
+
+export function readSetupCompletionRecord(
+  memoraxCodeHome?: string,
+): SetupCompletionRecordState;
+
+export function writeSetupCompletionRecord(
+  options: {
+    memoraxCodeHome?: string;
+    completedAt: string;
+    completedByVersion: string;
+  },
+  runtime?: RuntimeRecordWriteRuntime,
+): RuntimeRecordWriteResult<SetupCompletionRecord>;
+
+export function clearSetupCompletionRecord(
+  memoraxCodeHome?: string,
+  options?: JsonFileLockOptions,
+): Promise<SetupCompletionClearResult>;
+
+export function withSetupCompletionLock<T>(
+  memoraxCodeHome: string,
+  operation: (
+    state: WritableSetupCompletionRecordState,
+    mutation: SetupCompletionLockMutation,
+  ) => T | Promise<T>,
+  options?: JsonFileLockOptions,
+): Promise<T>;

package/lib/memorax-code-adapter-common/src/setup-completion.mjs

@@ -0,0 +1,154 @@
+import { unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { withJsonFileLockAsync } from "./config-utils.mjs";
+import {
+  readJsonRuntimeRecord,
+  RuntimeRecordError,
+  writePrivateJsonRecord,
+} from "./runtime-record.mjs";
+
+export const SETUP_COMPLETION_RECORD_VERSION = 1;
+
+const SETUP_COMPLETION_RECORD_KEYS = new Set([
+  "version",
+  "state",
+  "completedAt",
+  "completedByVersion",
+]);
+const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+
+export class SetupCompletionRecordError extends RuntimeRecordError {
+  constructor(state, path) {
+    super({
+      name: "Setup completion record",
+      path,
+      state,
+      codePrefix: "SETUP_COMPLETION_RECORD",
+      recovery: state.status === "unsupported"
+        ? "upgrade MemoraX Code or restore a supported setup completion record"
+        : "inspect the setup completion record before replacing it",
+    });
+    this.name = "SetupCompletionRecordError";
+  }
+}
+
+export function setupCompletionPath(memoraxCodeHome = defaultMemoraxCodeHome()) {
+  return join(memoraxCodeHome, "runtime", "setup", "setup-completion.json");
+}
+
+export function readSetupCompletionRecord(memoraxCodeHome = defaultMemoraxCodeHome()) {
+  const path = setupCompletionPath(memoraxCodeHome);
+  const state = readJsonRuntimeRecord(path);
+  if (state.status !== "present") return state;
+  const value = state.value;
+  if (value.version !== SETUP_COMPLETION_RECORD_VERSION) {
+    if (Number.isSafeInteger(value.version) && value.version > 0) {
+      return { status: "unsupported", version: value.version };
+    }
+    return { status: "invalid", reason: "invalid_version" };
+  }
+  if (Object.keys(value).some((key) => !SETUP_COMPLETION_RECORD_KEYS.has(key))) {
+    return { status: "invalid", reason: "unknown_fields" };
+  }
+  if (value.state !== "complete") {
+    return { status: "invalid", reason: "invalid_state" };
+  }
+  const completedAt = isoTimestamp(value.completedAt);
+  if (!completedAt) return { status: "invalid", reason: "invalid_completed_at" };
+  const completedByVersion = nonEmptyString(value.completedByVersion);
+  if (!completedByVersion) {
+    return { status: "invalid", reason: "invalid_completed_by_version" };
+  }
+  return {
+    status: "valid",
+    record: {
+      version: SETUP_COMPLETION_RECORD_VERSION,
+      state: "complete",
+      completedAt,
+      completedByVersion,
+    },
+  };
+}
+
+export function writeSetupCompletionRecord(options, runtime) {
+  const memoraxCodeHome = nonEmptyString(options?.memoraxCodeHome) ?? defaultMemoraxCodeHome();
+  const completedAt = isoTimestamp(options?.completedAt);
+  if (!completedAt) {
+    throw new TypeError("Setup completion record requires a valid ISO completedAt timestamp");
+  }
+  const completedByVersion = nonEmptyString(options?.completedByVersion);
+  if (!completedByVersion) {
+    throw new TypeError("Setup completion record requires a non-empty completedByVersion");
+  }
+  const path = setupCompletionPath(memoraxCodeHome);
+  const existing = readSetupCompletionRecord(memoraxCodeHome);
+  if (existing.status === "invalid" || existing.status === "unsupported") {
+    throw new SetupCompletionRecordError(existing, path);
+  }
+  return writePrivateJsonRecord(path, {
+    version: SETUP_COMPLETION_RECORD_VERSION,
+    state: "complete",
+    completedAt,
+    completedByVersion,
+  }, {
+    ...runtime,
+    durableBoundary: memoraxCodeHome,
+  });
+}
+
+export async function clearSetupCompletionRecord(
+  memoraxCodeHome = defaultMemoraxCodeHome(),
+  options,
+) {
+  const home = nonEmptyString(memoraxCodeHome) ?? defaultMemoraxCodeHome();
+  return await withSetupCompletionLock(
+    home,
+    (_state, mutation) => mutation.clear(),
+    options,
+  );
+}
+
+export async function withSetupCompletionLock(
+  memoraxCodeHome,
+  operation,
+  options,
+) {
+  const home = nonEmptyString(memoraxCodeHome);
+  if (!home) throw new TypeError("Setup completion lock requires a MemoraX Code home");
+  if (typeof operation !== "function") {
+    throw new TypeError("Setup completion lock requires an operation");
+  }
+  const path = setupCompletionPath(home);
+  return await withJsonFileLockAsync(path, async () => {
+    let state = readSetupCompletionRecord(home);
+    if (state.status === "invalid" || state.status === "unsupported") {
+      throw new SetupCompletionRecordError(state, path);
+    }
+    return await operation(state, {
+      clear() {
+        if (state.status === "absent") return { path, removed: false };
+        unlinkSync(path);
+        state = { status: "absent" };
+        return { path, removed: true };
+      },
+    });
+  }, options);
+}
+
+function defaultMemoraxCodeHome() {
+  return join(homedir(), ".memorax-code");
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function isoTimestamp(value) {
+  const candidate = nonEmptyString(value);
+  return candidate
+    && ISO_TIMESTAMP_PATTERN.test(candidate)
+    && Number.isFinite(Date.parse(candidate))
+    ? candidate
+    : undefined;
+}

package/lib/memorax-code-backend/dist/clients/claude/memory-hook-runtime.js

@@ -1,5 +1,6 @@
 import { readClaudeInterruptedTranscriptTurn, readClaudeTranscriptTurn, } from "./transcript-turn.js";
 import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.js";
+import { claimQuotaNotice, createPendingQuotaNoticeRuntime, } from "../../memory/quota-notice.js";
 import { createAutomaticMemoryWritebackRuntime, } from "../../memory/automatic-writeback.js";
 import { createMemoryTurnCoordinator, } from "../../memory/turn-coordinator.js";
 import { createRepositoryMemorySessionRuntime, resolvedRepoMemoryWorktree, } from "../../memory/repository-session.js";
@@ -10,11 +11,20 @@ const DEFAULT_TRANSCRIPT_READ_ATTEMPTS = 6;
 const DEFAULT_TRANSCRIPT_RETRY_DELAY_MS = 100;
 export function createClaudeMemoryHookRuntime(options = {}) {
     const now = options.now ?? (() => Date.now());
+    const pendingQuotaNotice = options.pendingQuotaNotice ?? createPendingQuotaNoticeRuntime({
+        claimQuotaNotice: options.claimQuotaNotice,
+        diagnosticLogger: options.diagnosticLogger,
+        env: options.env,
+    });
+    const ownsPendingQuotaNotice = options.pendingQuotaNotice === undefined;
     const automaticWritebackRuntime = options.turnCoordinator
         ? undefined
         : options.automaticWriteback
             ? { enqueue: options.automaticWriteback }
-            : createAutomaticMemoryWritebackRuntime({ diagnosticLogger: options.diagnosticLogger });
+            : createAutomaticMemoryWritebackRuntime({
+                diagnosticLogger: options.diagnosticLogger,
+                queueQuotaNotice: pendingQuotaNotice.queue,
+            });
     const turnCoordinator = options.turnCoordinator ?? createMemoryTurnCoordinator({
         automaticWriteback: automaticWritebackRuntime.enqueue,
         now,
@@ -86,14 +96,19 @@ export function createClaudeMemoryHookRuntime(options = {}) {
                 env: options.env,
                 now: () => new Date(now()),
             }), options.diagnosticLogger);
-            if (!claimAutomaticRetrievalPrompt(automaticRetrievalPrompts, automaticRetrievalPromptLimit, turn.sessionId, turn.promptId)) {
+            const processTurnStart = claimAutomaticRetrievalPrompt(automaticRetrievalPrompts, automaticRetrievalPromptLimit, turn.sessionId, turn.promptId);
+            if (!processTurnStart) {
                 return {
                     ok: true,
                     ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
                 };
             }
+            const pendingUserNotice = repositoryMemory.ok
+                ? await pendingQuotaNotice.claim(repositoryMemory.memory.config)
+                : undefined;
             const retrieval = await retrieveAutomaticMemoryContext({
                 diagnosticLogger: options.diagnosticLogger,
+                claimQuotaNotice: options.claimQuotaNotice ?? claimQuotaNotice,
                 env: options.env ?? process.env,
                 fetchImpl: options.fetchImpl,
                 memoryObservability: options.memoryObservability,
@@ -103,10 +118,12 @@ export function createClaudeMemoryHookRuntime(options = {}) {
                 sessionKey: turn.sessionId,
                 traceContext: turn.traceContext,
             });
+            const userNotice = [pendingUserNotice, retrieval.userNotice].filter(Boolean).join("\n");
             return {
                 ok: true,
                 ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
                 ...(retrieval.context ? { additionalContext: retrieval.context } : {}),
+                ...(userNotice ? { userNotice } : {}),
             };
         },
         async writeback(command) {
@@ -195,6 +212,8 @@ export function createClaudeMemoryHookRuntime(options = {}) {
             if (ownsRepositoryMemorySession)
                 repositoryMemorySession.close();
             automaticWritebackRuntime?.close?.();
+            if (ownsPendingQuotaNotice)
+                pendingQuotaNotice.close();
         },
     };
 }

package/lib/memorax-code-backend/dist/clients/codex/memory-hook-runtime.js

@@ -1,6 +1,7 @@
 import { readCodexInterruptedRolloutTurn, readCodexRolloutTurn, } from "./rollout-turn.js";
 import { createAutomaticMemoryWritebackRuntime, } from "../../memory/automatic-writeback.js";
 import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.js";
+import { claimQuotaNotice, createPendingQuotaNoticeRuntime, } from "../../memory/quota-notice.js";
 import { readCodexSessionTurnIndex } from "./session-turn-index.js";
 import { resolveCodexWorkspaceRoot } from "./workspace-links.js";
 import { createMemoryTurnCoordinator, } from "../../memory/turn-coordinator.js";
@@ -10,11 +11,20 @@ import { markCurrentCodexTurnOutcome, readCurrentCodexTurn, readOpenCodexTurn, r
 const CODEX_MEMORY_TURN_CLIENT = "codex";
 export function createCodexMemoryHookRuntime(options = {}) {
     const now = options.now ?? (() => Date.now());
+    const pendingQuotaNotice = options.pendingQuotaNotice ?? createPendingQuotaNoticeRuntime({
+        claimQuotaNotice: options.claimQuotaNotice,
+        diagnosticLogger: options.diagnosticLogger,
+        env: options.env,
+    });
+    const ownsPendingQuotaNotice = options.pendingQuotaNotice === undefined;
     const automaticWritebackRuntime = options.turnCoordinator
         ? undefined
         : options.automaticWriteback
             ? { enqueue: options.automaticWriteback }
-            : createAutomaticMemoryWritebackRuntime({ diagnosticLogger: options.diagnosticLogger });
+            : createAutomaticMemoryWritebackRuntime({
+                diagnosticLogger: options.diagnosticLogger,
+                queueQuotaNotice: pendingQuotaNotice.queue,
+            });
     const turnCoordinator = options.turnCoordinator ?? createMemoryTurnCoordinator({
         automaticWriteback: automaticWritebackRuntime.enqueue,
         now,
@@ -91,15 +101,21 @@ export function createCodexMemoryHookRuntime(options = {}) {
                 env: options.env,
                 now: () => new Date(now()),
             }), options.diagnosticLogger);
-            if (!turn.turnId
-                || !claimAutomaticRetrievalTurn(automaticRetrievalTurns, automaticRetrievalTurnLimit, turn.sessionId, turn.turnId)) {
+            const processTurnStart = turn.turnId
+                ? claimAutomaticRetrievalTurn(automaticRetrievalTurns, automaticRetrievalTurnLimit, turn.sessionId, turn.turnId)
+                : false;
+            if (!processTurnStart) {
                 return {
                     ok: true,
                     ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
                 };
             }
+            const pendingUserNotice = repositoryMemory.ok
+                ? await pendingQuotaNotice.claim(repositoryMemory.memory.config)
+                : undefined;
             const retrieval = await retrieveAutomaticMemoryContext({
                 diagnosticLogger: options.diagnosticLogger,
+                claimQuotaNotice: options.claimQuotaNotice ?? claimQuotaNotice,
                 env: options.env ?? process.env,
                 fetchImpl: options.fetchImpl,
                 memoryObservability: options.memoryObservability,
@@ -109,10 +125,12 @@ export function createCodexMemoryHookRuntime(options = {}) {
                 sessionKey: turn.sessionId,
                 traceContext: turn.traceContext,
             });
+            const userNotice = [pendingUserNotice, retrieval.userNotice].filter(Boolean).join("\n");
             return {
                 ok: true,
                 ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
                 ...(retrieval.context ? { additionalContext: retrieval.context } : {}),
+                ...(userNotice ? { userNotice } : {}),
             };
         },
         async writeback(command) {
@@ -222,6 +240,8 @@ export function createCodexMemoryHookRuntime(options = {}) {
             if (ownsRepositoryMemorySession)
                 repositoryMemorySession.close();
             automaticWritebackRuntime?.close?.();
+            if (ownsPendingQuotaNotice)
+                pendingQuotaNotice.close();
         },
     };
 }

package/lib/memorax-code-backend/dist/clients/opencode/memory-hook-runtime.js

@@ -1,5 +1,6 @@
 import { createAutomaticMemoryWritebackRuntime, } from "../../memory/automatic-writeback.js";
 import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.js";
+import { claimQuotaNotice, createPendingQuotaNoticeRuntime, } from "../../memory/quota-notice.js";
 import { createMemoryTurnCoordinator, } from "../../memory/turn-coordinator.js";
 import { createRepositoryMemorySessionRuntime, resolvedRepoMemoryWorktree, } from "../../memory/repository-session.js";
 import { traceContextFromOpenCodeHookBody } from "../../trace/context.js";
@@ -8,11 +9,20 @@ import { openCodeMessageTurn, } from "./message-turn.js";
 const OPENCODE_MEMORY_TURN_CLIENT = "opencode";
 export function createOpenCodeMemoryHookRuntime(options = {}) {
     const now = options.now ?? (() => Date.now());
+    const pendingQuotaNotice = options.pendingQuotaNotice ?? createPendingQuotaNoticeRuntime({
+        claimQuotaNotice: options.claimQuotaNotice,
+        diagnosticLogger: options.diagnosticLogger,
+        env: options.env,
+    });
+    const ownsPendingQuotaNotice = options.pendingQuotaNotice === undefined;
     const automaticWritebackRuntime = options.turnCoordinator
         ? undefined
         : options.automaticWriteback
             ? { enqueue: options.automaticWriteback }
-            : createAutomaticMemoryWritebackRuntime({ diagnosticLogger: options.diagnosticLogger });
+            : createAutomaticMemoryWritebackRuntime({
+                diagnosticLogger: options.diagnosticLogger,
+                queueQuotaNotice: pendingQuotaNotice.queue,
+            });
     const turnCoordinator = options.turnCoordinator ?? createMemoryTurnCoordinator({
         automaticWriteback: automaticWritebackRuntime.enqueue,
         now,
@@ -85,8 +95,12 @@ export function createOpenCodeMemoryHookRuntime(options = {}) {
                     break;
                 retrievalTurns.delete(oldest);
             }
+            const pendingUserNotice = repositoryMemory.ok
+                ? await pendingQuotaNotice.claim(repositoryMemory.memory.config)
+                : undefined;
             const retrieval = await retrieveAutomaticMemoryContext({
                 diagnosticLogger: options.diagnosticLogger,
+                claimQuotaNotice: options.claimQuotaNotice ?? claimQuotaNotice,
                 env: options.env ?? process.env,
                 fetchImpl: options.fetchImpl,
                 memoryObservability: options.memoryObservability,
@@ -96,10 +110,12 @@ export function createOpenCodeMemoryHookRuntime(options = {}) {
                 sessionKey: command.sessionId,
                 traceContext,
             });
+            const userNotice = [pendingUserNotice, retrieval.userNotice].filter(Boolean).join("\n");
             return {
                 ok: true,
                 ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
                 ...(retrieval.context ? { additionalContext: retrieval.context } : {}),
+                ...(userNotice ? { userNotice } : {}),
             };
         },
         async writeback(command) {
@@ -229,6 +245,8 @@ export function createOpenCodeMemoryHookRuntime(options = {}) {
             if (ownsRepositoryMemorySession)
                 repositoryMemorySession.close();
             automaticWritebackRuntime?.close?.();
+            if (ownsPendingQuotaNotice)
+                pendingQuotaNotice.close();
         },
     };
 }

package/lib/memorax-code-backend/dist/entrypoints/backend-cli.js

@@ -471,7 +471,8 @@ function isRecord(value) {
 }
 function printMemoraxCodeStatus(report) {
     const backend = report.backend;
-    backendLog(`MemoraX Code Backend status: ${report.ok ? blueBold("Enabled") : redBold("Unavailable")}`);
+    const degraded = report.degraded === true;
+    backendLog(`MemoraX Code Backend status: ${report.ok ? blueBold(degraded ? "Enabled (degraded)" : "Enabled") : redBold("Unavailable")}`);
     backendLog(report.ok
         ? green("MemoraX Code is ready for new client sessions.")
         : red("MemoraX Code is not ready for new client sessions."));
@@ -567,7 +568,7 @@ export async function runBackendTokenCommand(serviceOptions, argv, recordWriteRu
     }
 }
 function printLifecycleResult(report) {
-    const degraded = report.backend?.degraded === true;
+    const degraded = report.degraded === true || report.backend?.degraded === true;
     backendLog(`${lifecycleActionLabel(report.action)}: ${report.ok ? green(degraded ? "ok (degraded)" : "ok") : red("needs attention")}`);
     if (report.message)
         backendLog(report.message);
@@ -651,29 +652,29 @@ function lifecycleGuidance(report) {
                 "Adapters were not changed for this command.",
             ];
         }
-        const optionalDshSkipped = isOptionalUnavailableDshAdapter(report.dshAdapter);
+        const optionalDshUnavailable = isOptionalUnavailableDshAdapter(report.dshAdapter);
         if ((!report.codexAdapter || isAdapterReady(report.codexAdapter))
             && (!report.claudeAdapter || isAdapterReady(report.claudeAdapter))
             && (!report.dshAdapter
                 || isAdapterReady(report.dshAdapter)
-                || optionalDshSkipped)
+                || optionalDshUnavailable)
             && (!report.opencodeAdapter || isAdapterReady(report.opencodeAdapter))) {
             return [
-                green(optionalDshSkipped
+                green(optionalDshUnavailable
                     && !report.codexAdapter
                     && !report.claudeAdapter
                     && !report.opencodeAdapter
-                    ? "Backend is running; the optional DSH integration was skipped."
+                    ? "Backend is running; the optional DSH integration is unavailable."
                     : "Backend is running and available client integrations are enabled."),
-                ...(optionalDshSkipped
-                    ? [`DSH integration was skipped: ${report.dshAdapter?.reason ?? "not available"}.`]
+                ...(optionalDshUnavailable
+                    ? [`DSH integration is unavailable: ${report.dshAdapter?.reason ?? "not available"}.`]
                     : []),
                 ...(report.codexAdapter || report.claudeAdapter || report.opencodeAdapter
                     ? [
                         green("Existing sessions with the stable plugin shell select the active runtime on their next user prompt."),
                         "Restart or refresh a client only if its plugin shell changed or MemoraX Code is not active on the next prompt.",
                     ]
-                    : optionalDshSkipped
+                    : optionalDshUnavailable
                         ? []
                         : [green("New DSH sessions can use MemoraX Code through the active Profile integration.")]),
             ];
@@ -741,15 +742,15 @@ function lifecycleGuidance(report) {
 }
 function statusGuidance(report) {
     if (report.ok) {
-        const optionalDshSkipped = isOptionalUnavailableDshAdapter(report.dshAdapter);
+        const optionalDshUnavailable = isOptionalUnavailableDshAdapter(report.dshAdapter);
         if (report.dshAdapter
             && !report.codexAdapter
             && !report.claudeAdapter
             && !report.opencodeAdapter) {
-            if (optionalDshSkipped) {
+            if (optionalDshUnavailable) {
                 return [
-                    green("Backend is running; the optional DSH integration was skipped."),
-                    `DSH integration was skipped: ${report.dshAdapter.reason ?? "not available"}.`,
+                    green("Backend is running; the optional DSH integration is unavailable."),
+                    `DSH integration is unavailable: ${report.dshAdapter.reason ?? "not available"}.`,
                 ];
             }
             return [
@@ -759,8 +760,8 @@ function statusGuidance(report) {
         }
         return [
             green("MemoraX Code is ready; sessions with the stable plugin shell use the active Hook runtime on their next user prompt."),
-            ...(optionalDshSkipped
-                ? [`DSH integration was skipped: ${report.dshAdapter?.reason ?? "not available"}.`]
+            ...(optionalDshUnavailable
+                ? [`DSH integration is unavailable: ${report.dshAdapter?.reason ?? "not available"}.`]
                 : []),
             "Restart or refresh a client only if its plugin shell was installed, changed, or newly enabled, or MemoraX Code is not active on the next prompt.",
         ];
@@ -877,7 +878,7 @@ function claudeAdapterStatusLine(report, codexAdapter) {
 }
 function dshAdapterStatusLine(report) {
     if (isOptionalUnavailableDshAdapter(report)) {
-        return `skipped ${report.reason ?? "not-detected"}`;
+        return `unavailable ${report.reason ?? "not-detected"}`;
     }
     const version = report.version ?? report.dshVersion;
     const tested = version && report.dshVersionTested !== undefined

package/lib/memorax-code-backend/dist/lifecycle/backend/process.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
 const POSIX_PROCESS_PROBE_TIMEOUT_MS = 2_000;
 const WINDOWS_PROCESS_PROBE_TIMEOUT_MS = 10_000;
@@ -48,6 +49,26 @@ export function probeProcessCommandLine(pid, runtime = {}) {
     if (!Number.isSafeInteger(pid) || pid <= 0) {
         return { status: "inconclusive", reason: "invalid_pid", timeoutMs };
     }
+    if (platform === "linux") {
+        try {
+            const rawCommandLine = (runtime.readFileSync ?? readFileSync)(`/proc/${pid}/cmdline`);
+            const commandLine = rawCommandLine.toString("utf8").replaceAll("\0", " ").trim();
+            return commandLine
+                ? { status: "ok", commandLine }
+                : { status: "not_found" };
+        }
+        catch (error) {
+            const code = error instanceof Error
+                ? error.code
+                : undefined;
+            return {
+                status: "inconclusive",
+                reason: "read_error",
+                timeoutMs,
+                ...(code ? { code } : {}),
+            };
+        }
+    }
     const run = runtime.spawnSync ?? runProbeCommand;
     let command;
     let args;