@memorax/memorax-code 0.1.1 → 0.1.3

package/lib/memorax-code-dsh-adapter/skills/memorax-code/scripts/validate_memory.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""Validate authored repo-memory bundles."""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+
+BASELINE_FILES = [
+    Path("PROFILE.md"),
+    Path("resources/commits.md"),
+    Path("resources/prs.md"),
+    Path("resources/issues.md"),
+    Path("raw/git-commits.json"),
+]
+
+PROVIDER_RAW_FILES = [Path("raw/github-facets.json"), Path("raw/gitlab-facets.json")]
+PROVIDER_RESOURCE_FILES = [Path("resources/prs.md"), Path("resources/issues.md")]
+DISABLED_RESOURCE_SOURCES = {"history_disabled", "provider_skipped_local_only", "provider_unavailable", "github_resource_facets_unavailable", "gitlab_resource_facets_unavailable", "provider_unavailable_local_only"}
+USER_PROFILE_SIDECAR = Path("user-profile/preferences.md")
+PROCEDURE_SIDECAR_DIRECTORY = "procedure-memory"
+PLACEHOLDER_RE = re.compile(r"\[([^\]\n]+)\]")
+LINK_TARGET_AFTER_BRACKET_RE = re.compile(r"[ \t\r\n]*\(")
+
+
+def relative(path: Path, memory: Path) -> str:
+    return path.relative_to(memory).as_posix()
+
+
+def resolve_memory_root(path: Path) -> Path:
+    candidate = path.expanduser().resolve()
+    if candidate.name == ".repo_memory":
+        return candidate
+    return candidate / ".repo_memory"
+
+
+def parse_frontmatter(text: str) -> dict[str, Any]:
+    if not text.startswith("---\n"):
+        return {}
+    end = text.find("\n---", 4)
+    if end == -1:
+        return {}
+    values: dict[str, Any] = {}
+    for line in text[4:end].splitlines():
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        key = key.strip()
+        value = value.strip()
+        if not key:
+            continue
+        if (value.startswith('"') and value.endswith('"')) or (value.startswith("'") and value.endswith("'")):
+            values[key] = value[1:-1]
+        elif re.fullmatch(r"-?\d+", value):
+            values[key] = int(value)
+        elif value.lower() == "true":
+            values[key] = True
+        elif value.lower() == "false":
+            values[key] = False
+        else:
+            values[key] = value
+    return values
+
+
+def body_after_frontmatter(text: str) -> str:
+    if not text.startswith("---\n"):
+        return text
+    end = text.find("\n---", 4)
+    if end == -1:
+        return text
+    return text[end + 4 :].lstrip("\n")
+
+
+def item_section_count(text: str) -> int:
+    body = body_after_frontmatter(text)
+    lines = body.splitlines()
+    title_seen = False
+    count = 0
+    for line in lines:
+        if line.startswith("# ") and not title_seen:
+            title_seen = True
+            continue
+        if title_seen and line.startswith("## "):
+            count += 1
+    return count
+
+
+def placeholder_matches(text: str) -> list[str]:
+    text = strip_markdown_code(text)
+    matches: list[str] = []
+    for match in PLACEHOLDER_RE.finditer(text):
+        if LINK_TARGET_AFTER_BRACKET_RE.match(text, match.end()):
+            continue
+        value = match.group(1).strip()
+        if not value or value.startswith("#"):
+            continue
+        if re.search(r"[A-Za-z]", value):
+            matches.append(f"[{value}]")
+    return matches
+
+
+def strip_markdown_code(text: str) -> str:
+    without_fences = re.sub(r"```.*?```", "", text, flags=re.DOTALL)
+    return re.sub(r"`[^`\n]*`", "", without_fences)
+
+
+def check_exists(memory: Path, rel_path: Path, errors: list[str], checked: list[str]) -> bool:
+    path = memory / rel_path
+    checked.append(rel_path.as_posix())
+    if not path.exists():
+        errors.append(f"{rel_path.as_posix()}: required file is missing")
+        return False
+    if not path.is_file():
+        errors.append(f"{rel_path.as_posix()}: expected a file")
+        return False
+    return True
+
+
+def validate_json(path: Path, memory: Path, errors: list[str], checked: list[str]) -> None:
+    checked.append(relative(path, memory))
+    try:
+        json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        errors.append(f"{relative(path, memory)}: invalid JSON at line {exc.lineno}, column {exc.colno}: {exc.msg}")
+    except OSError as exc:
+        errors.append(f"{relative(path, memory)}: could not read JSON: {exc}")
+
+
+def raw_source_points_to_provider(raw_source: Any) -> bool:
+    return isinstance(raw_source, str) and raw_source.endswith(("github-facets.json", "gitlab-facets.json"))
+
+
+def validate_markdown(path: Path, memory: Path, errors: list[str], warnings: list[str], checked: list[str]) -> None:
+    checked.append(relative(path, memory))
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        errors.append(f"{relative(path, memory)}: could not read Markdown: {exc}")
+        return
+
+    frontmatter = parse_frontmatter(text)
+    rel = relative(path, memory)
+    if not frontmatter.get("schema"):
+        errors.append(f"{rel}: frontmatter field 'schema' is missing")
+
+    placeholders = placeholder_matches(text)
+    if placeholders:
+        errors.append(f"{rel}: unresolved bracket placeholder(s): {', '.join(placeholders)}")
+
+    if path.parent.name != "resources":
+        return
+
+    for field in ["source", "resource_count", "trust_state", "raw_source"]:
+        if field not in frontmatter:
+            errors.append(f"{rel}: frontmatter field '{field}' is missing")
+
+    expected = frontmatter.get("resource_count")
+    actual = item_section_count(text)
+    if isinstance(expected, int):
+        if expected != actual:
+            errors.append(f"{rel}: resource_count is {expected}, but found {actual} item section(s)")
+    elif expected is not None:
+        errors.append(f"{rel}: resource_count must be an integer")
+
+    source = frontmatter.get("source")
+    raw_source = frontmatter.get("raw_source")
+    if "source" in frontmatter and not source:
+        errors.append(f"{rel}: frontmatter field 'source' must not be empty")
+    if "trust_state" in frontmatter and not frontmatter.get("trust_state"):
+        errors.append(f"{rel}: frontmatter field 'trust_state' must not be empty")
+    if source in DISABLED_RESOURCE_SOURCES and isinstance(expected, int) and expected != 0:
+        errors.append(f"{rel}: disabled or unavailable resource source {source!r} must use resource_count 0")
+    if source in DISABLED_RESOURCE_SOURCES and raw_source:
+        errors.append(f"{rel}: disabled or unavailable resource source {source!r} must use an empty raw_source")
+    if path.name in {"commits.md", "prs.md", "issues.md"} and source not in DISABLED_RESOURCE_SOURCES and raw_source == "":
+        errors.append(f"{rel}: empty raw_source requires a disabled or unavailable source")
+    if path.name in {"prs.md", "issues.md"} and raw_source_points_to_provider(raw_source):
+        provider_path = (path.parent / raw_source).resolve()
+        if not provider_path.exists():
+            errors.append(f"{rel}: provider raw evidence is missing for raw_source {raw_source!r}")
+
+
+def provider_raw_paths(memory: Path) -> list[Path]:
+    return [memory / rel for rel in PROVIDER_RAW_FILES if (memory / rel).exists()]
+
+
+def validate(memory: Path) -> dict[str, Any]:
+    errors: list[str] = []
+    warnings: list[str] = []
+    checked: list[str] = []
+
+    if not memory.exists():
+        errors.append(f"{memory}: .repo_memory directory is missing")
+        return {"ok": False, "errors": errors, "warnings": warnings, "checked": checked}
+    if not memory.is_dir():
+        errors.append(f"{memory}: expected .repo_memory to be a directory")
+        return {"ok": False, "errors": errors, "warnings": warnings, "checked": checked}
+
+    for rel_path in BASELINE_FILES:
+        check_exists(memory, rel_path, errors, checked)
+
+    markdown_paths = sorted(
+        path
+        for path in memory.rglob("*.md")
+        if path.is_file()
+        and path.relative_to(memory) != USER_PROFILE_SIDECAR
+        and path.relative_to(memory).parts[0] != PROCEDURE_SIDECAR_DIRECTORY
+    )
+    for path in markdown_paths:
+        if path.exists() and path.is_file():
+            validate_markdown(path, memory, errors, warnings, checked)
+
+    json_paths = sorted(path for path in (memory / "raw").rglob("*.json") if path.is_file())
+    provider_raw = provider_raw_paths(memory)
+
+    if provider_raw:
+        for rel_path in PROVIDER_RESOURCE_FILES:
+            check_exists(memory, rel_path, errors, checked)
+
+    seen_json: set[Path] = set()
+    for path in json_paths:
+        if path.exists() and path.is_file() and path not in seen_json:
+            seen_json.add(path)
+            validate_json(path, memory, errors, checked)
+
+    checked = sorted(dict.fromkeys(checked))
+    return {"ok": not errors, "errors": errors, "warnings": warnings, "checked": checked}
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate a repo-memory bundle.")
+    parser.add_argument("path", help="Path to a repository or its .repo_memory directory")
+    parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON output")
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str]) -> int:
+    args = parse_args(argv)
+    report = validate(resolve_memory_root(Path(args.path)))
+    print(json.dumps(report, ensure_ascii=False, indent=2 if args.pretty else None))
+    return 0 if report["ok"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/lib/memorax-code-dsh-adapter/src/backend-client.mjs

@@ -0,0 +1,119 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { resolveBackendConnection } from "../memorax-code-adapter-common/src/backend-connection.mjs";
+import {
+  ensureBackendAvailable,
+  stringValue,
+} from "../memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs";
+import { createHttpBackendClient } from "./http-client.mjs";
+import { requireEnabledDshRuntime } from "./runtime-state.mjs";
+
+// The package assembler materializes adapter-common inside this DSH bundle so
+// a profile-local file: install never depends on the parent npm package tree.
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+export function createDshBackendClient(options = {}) {
+  const env = options.env ?? process.env;
+  const root = options.pluginRoot ?? pluginRoot;
+  const resolveRuntime = options.resolveRuntime
+    ?? (() => requireEnabledDshRuntime(root));
+  const resolveConnection = options.resolveConnection
+    ?? ((runtime) => resolveBackendConnection({ memoraxCodeHome: runtime.memoraxCodeHome, env }));
+  const ensureBackend = options.ensureBackend ?? ensureBackendAvailable;
+  const httpClient = options.httpClient ?? createHttpBackendClient({
+    env,
+    resolveConnection: () => resolveConnection(resolveRuntime()),
+  });
+  let ensureInFlight;
+  let ensureRevision;
+
+  async function ensureReady() {
+    // This read intentionally precedes the in-flight fast path. A running DSH
+    // process must observe stop/uninstall before it can reuse Backend recovery.
+    const runtime = resolveRuntime();
+    if (ensureInFlight) {
+      if (ensureRevision === runtime.revision) return ensureInFlight;
+      await ensureInFlight.catch(() => undefined);
+      return ensureReady();
+    }
+    const connection = resolveConnection(runtime);
+    ensureRevision = runtime.revision;
+    const pending = Promise.resolve(ensureBackend({
+      backendConnection: connection,
+      ensureBackendValue: env.MEMORAX_CODE_DSH_ENSURE_BACKEND,
+      healthTimeoutValue: env.MEMORAX_CODE_DSH_ENSURE_TIMEOUT_MS,
+      startTimeoutValue: env.MEMORAX_CODE_DSH_START_TIMEOUT_MS,
+      memoraxCodeCommand: stringValue(env.MEMORAX_CODE_DSH_LIFECYCLE_COMMAND)
+        ?? stringValue(env.MEMORAX_CODE_COMMAND)
+        ?? runtime.memoraxCodeCommand,
+      nodePath: process.execPath,
+      pluginRoot: root,
+      resolveHomes: () => ({ memoraxCodeHome: runtime.memoraxCodeHome }),
+      buildStartArgs: (homes, recoveryArguments) => [
+        "start",
+        "--home",
+        homes.memoraxCodeHome,
+        ...recoveryArguments,
+      ],
+      recoveryEnv: {
+        MEMORAX_CODE_DSH_ADAPTER_RECOVERY: "1",
+        MEMORAX_CODE_DSH_ADAPTER_EXPECTED_REVISION: runtime.revision,
+      },
+      debug: options.debug ?? debugEnsure,
+    }));
+    const tracked = pending.finally(() => {
+      if (ensureInFlight === tracked) {
+        ensureInFlight = undefined;
+        ensureRevision = undefined;
+      }
+    });
+    ensureInFlight = tracked;
+    return ensureInFlight;
+  }
+
+  return Object.freeze({
+    ensureReady,
+    async recordTurnStart(command, request) {
+      await waitForEnsure(ensureReady(), request?.signal, 12_000);
+      return httpClient.recordTurnStart(command, request);
+    },
+    async recordSkillReminder(command, request) {
+      await waitForEnsure(ensureReady(), request?.signal, 5_000);
+      return httpClient.recordSkillReminder(command, request);
+    },
+    async writebackTurn(command, request) {
+      await waitForEnsure(ensureReady(), request?.signal, 5_000);
+      return httpClient.writebackTurn(command, request);
+    },
+  });
+}
+
+export const backendClient = createDshBackendClient();
+
+async function waitForEnsure(promise, signal, timeoutMs) {
+  signal?.throwIfAborted();
+  let timer;
+  let abort;
+  const boundary = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("MemoraX Code Backend recovery timed out")), timeoutMs);
+    if (signal) {
+      abort = () => reject(signal.reason instanceof Error ? signal.reason : new Error("aborted"));
+      signal.addEventListener("abort", abort, { once: true });
+    }
+  });
+  try {
+    await Promise.race([promise, boundary]);
+  } finally {
+    clearTimeout(timer);
+    if (abort) signal.removeEventListener("abort", abort);
+  }
+}
+
+function debugEnsure(message) {
+  if (process.env.MEMORAX_CODE_DSH_DEBUG === "1") {
+    console.error(message);
+  }
+}
+
+export default backendClient;

package/lib/memorax-code-dsh-adapter/src/dsh-message.mjs

@@ -0,0 +1,32 @@
+import { randomUUID } from "node:crypto";
+
+/** Create the same detached, identified, deeply frozen UserMessage as DSH. */
+export function createDshUserMessage(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new TypeError("DSH UserMessage input must be an object");
+  }
+  if (Object.hasOwn(input, "id") || Object.hasOwn(input, "role")) {
+    throw new TypeError("DSH UserMessage input must not supply id or role");
+  }
+  return deepFreeze(structuredClone({
+    ...input,
+    role: "user",
+    id: randomUUID(),
+  }));
+}
+
+// Mirrors DSH's public createUserMessage -> freezeMessage -> deepFreeze
+// construction contract without depending on DSH internals.
+function deepFreeze(value) {
+  const seen = new WeakSet();
+  const pending = [value];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (node === null || typeof node !== "object" || node instanceof AbortSignal) continue;
+    if (seen.has(node)) continue;
+    seen.add(node);
+    Object.freeze(node);
+    for (const key of Object.keys(node)) pending.push(node[key]);
+  }
+  return value;
+}

package/lib/memorax-code-dsh-adapter/src/dsh-version.mjs

@@ -0,0 +1,18 @@
+export const DSH_TESTED_VERSIONS = Object.freeze(["0.1.0-rc.6"]);
+
+const DSH_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const DSH_VERSION_MAX_LENGTH = 128;
+
+export function parseDshVersion(value) {
+  const version = typeof value === "string" ? value.trim() : "";
+  return version
+    && version.length <= DSH_VERSION_MAX_LENGTH
+    && DSH_VERSION_PATTERN.test(version)
+    ? version
+    : undefined;
+}
+
+export function isTestedDshVersion(value) {
+  const version = parseDshVersion(value);
+  return version !== undefined && DSH_TESTED_VERSIONS.includes(version);
+}

package/lib/memorax-code-dsh-adapter/src/http-client.mjs

@@ -0,0 +1,55 @@
+const RETRIEVAL_BACKEND_TIMEOUT_MS = 12_000;
+const DEFAULT_BACKEND_TIMEOUT_MS = 5_000;
+
+/** Create the narrow Backend port consumed by the Cordis plugin. */
+export function createHttpBackendClient(options) {
+  const resolveConnection = options?.resolveConnection;
+  const fetchImpl = options?.fetchImpl ?? globalThis.fetch;
+  const env = options?.env ?? process.env;
+  if (typeof resolveConnection !== "function") {
+    throw new TypeError("DSH Backend client requires resolveConnection");
+  }
+  if (typeof fetchImpl !== "function") throw new TypeError("DSH Backend client requires fetch");
+
+  return Object.freeze({
+    recordTurnStart(command, request = {}) {
+      return post("/memory/turn-start", command, request.signal);
+    },
+    recordSkillReminder(command, request = {}) {
+      return post("/memory/skill-reminder", command, request.signal);
+    },
+    writebackTurn(command, request = {}) {
+      return post("/memory/writeback", command, request.signal);
+    },
+  });
+
+  async function post(path, body, callerSignal) {
+    const connection = resolveConnection();
+    const timeoutMs = positiveInteger(
+      env.MEMORAX_CODE_DSH_MEMORY_HOOK_TIMEOUT_MS,
+      path === "/memory/turn-start" ? RETRIEVAL_BACKEND_TIMEOUT_MS : DEFAULT_BACKEND_TIMEOUT_MS,
+    );
+    const headers = { "content-type": "application/json", connection: "close" };
+    if (connection.token) headers["x-memorax-code-backend-token"] = connection.token;
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const signal = callerSignal
+      ? AbortSignal.any([callerSignal, timeoutSignal])
+      : timeoutSignal;
+    const response = await fetchImpl(new URL(path, connection.url), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal,
+    });
+    if (!response.ok) {
+      await response.arrayBuffer().catch(() => undefined);
+      throw new Error(`MemoraX Code Backend ${path} returned HTTP ${response.status}`);
+    }
+    return await response.json().catch(() => undefined);
+  }
+}
+
+function positiveInteger(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/lib/memorax-code-dsh-adapter/src/index.mjs

@@ -0,0 +1,72 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  isMemorySkillReminderDue,
+  memorySkillReminderContext,
+  personalMemoryReminderContext,
+  resolveMemorySkillReminderIntervalTurns,
+} from "../memorax-code-adapter-common/src/hooks/memory-skill-reminder-policy.mjs";
+import { scheduleMissingRepoMemoryBuild } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-auto-build.mjs";
+import { isRepoMemoryJobWorker } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+import backendClient from "./backend-client.mjs";
+import { createDshUserMessage } from "./dsh-message.mjs";
+import { loadDshPersonalContext } from "./personal-context.mjs";
+import { PLUGIN_NAME, registerMemoraxCodePlugin } from "./plugin.mjs";
+import { requireEnabledDshRuntime } from "./runtime-state.mjs";
+
+export const name = PLUGIN_NAME;
+export const inject = ["agents", "sessions", "sessionPersistence"];
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+export function apply(ctx) {
+  if (isRepoMemoryJobWorker()) return;
+  let runtime;
+  try {
+    runtime = requireEnabledDshRuntime(pluginRoot);
+  } catch (error) {
+    if (error?.code === "MEMORAX_CODE_DSH_DISABLED") return;
+    throw error;
+  }
+  const runtimeEnv = {
+    ...process.env,
+    MEMORAX_CODE_HOME: runtime.memoraxCodeHome,
+  };
+  const intervalTurns = resolveMemorySkillReminderIntervalTurns({
+    environmentValue: runtimeEnv.MEMORAX_CODE_MEMORY_SKILL_REMINDER_INTERVAL_TURNS,
+    configText: readConfig(join(runtime.memoraxCodeHome, "config.toml")),
+  });
+  registerMemoraxCodePlugin(ctx, {
+    assertEnabled: () => requireEnabledDshRuntime(pluginRoot),
+    backendClient,
+    createUserMessage: createDshUserMessage,
+    intervalTurns,
+    isReminderDue: isMemorySkillReminderDue,
+    memoryReminderContext: memorySkillReminderContext("/memorax-code"),
+    loadPersonalContext: (input, options) => loadDshPersonalContext(input, {
+      ...options,
+      env: runtimeEnv,
+    }),
+    personalMemoryReminderContext: personalMemoryReminderContext("/memorax-code"),
+    scheduleRepoMemoryBuild: (repo) => scheduleMissingRepoMemoryBuild(repo, {
+      pluginRoot,
+      env: runtimeEnv,
+      debugEnv: "MEMORAX_CODE_DSH_DEBUG",
+    }),
+  });
+  void backendClient.ensureReady().catch((error) => {
+    if (process.env.MEMORAX_CODE_DSH_DEBUG !== "1") return;
+    const detail = error instanceof Error ? error.message : String(error);
+    ctx.logger?.warn?.(`memorax-code Backend recovery failed: ${detail}`);
+  });
+}
+
+function readConfig(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return undefined;
+  }
+}

package/lib/memorax-code-dsh-adapter/src/personal-context-worker.mjs

@@ -0,0 +1,48 @@
+import { buildRepoProcedureMemoryContext } from "../memorax-code-adapter-common/src/repo-memory/repo-procedure-memory-context.mjs";
+import { buildRepoUserProfilePreferencesContext } from "../memorax-code-adapter-common/src/repo-memory/repo-user-profile-context.mjs";
+
+const MAX_INPUT_BYTES = 16 * 1024;
+const contextOptions = {
+  adapterDir: "dsh",
+  debugEnv: "MEMORAX_CODE_DSH_DEBUG",
+  sessionKeyPrefix: "dsh",
+};
+
+try {
+  const input = await readInput();
+  const profileContext = input.includeProfile
+    ? buildRepoUserProfilePreferencesContext({ cwd: input.cwd }, contextOptions)
+    : undefined;
+  const procedureContext = input.includeProcedure
+    ? buildRepoProcedureMemoryContext({ cwd: input.cwd }, contextOptions)
+    : undefined;
+  process.stdout.write(`${JSON.stringify({
+    ...(profileContext ? { profileContext } : {}),
+    ...(procedureContext ? { procedureContext } : {}),
+  })}\n`);
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+}
+
+async function readInput() {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of process.stdin) {
+    bytes += chunk.length;
+    if (bytes > MAX_INPUT_BYTES) throw new Error("DSH personal context worker input exceeded its limit");
+    chunks.push(chunk);
+  }
+  const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  const cwd = nonEmptyString(value?.cwd);
+  const includeProfile = value?.includeProfile === true;
+  const includeProcedure = value?.includeProcedure === true;
+  if (!cwd || (!includeProfile && !includeProcedure)) {
+    throw new Error("DSH personal context worker received invalid input");
+  }
+  return { cwd, includeProfile, includeProcedure };
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}