@jstn-sdk/ma 0.1.13 → 0.14.1

package/src/runtime/redaction-gateway.js

@@ -1,4 +1,6 @@
 import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { readJson, writeFileIfMissing, writeJson } from "../fs-utils.js";
 import { getRuntimeStatePath } from "../paths.js";
 import { appendMaestroEvent } from "./maestro-events.js";
@@ -21,6 +23,11 @@ const redactionRules = [
     regex:
       /\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9_]{16,}|xox[baprs]-[A-Za-z0-9-]{10,}|AIza[0-9A-Za-z-_]{20,})\b/g,
   },
+  {
+    placeholderBase: "__MA_SECURE_ASSIGNMENT__",
+    regex:
+      /\b(?:API_KEY|API_TOKEN|AUTH_TOKEN|SECRET_KEY|DATABASE_URL|PRIVATE_KEY|PASSWORD)\s*=\s*(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi,
+  },
 ];
 
 export function getRedactionVaultPath() {
@@ -34,9 +41,23 @@ function createDefaultVault() {
   };
 }
 
+export function getRedactionVaultPolicy() {
+  const retentionDays = Number.parseInt(process.env.MA_REDACTION_VAULT_RETENTION_DAYS ?? "30", 10);
+  const maxEntries = Number.parseInt(process.env.MA_REDACTION_VAULT_MAX_ENTRIES ?? "200", 10);
+  return {
+    retentionDays: Number.isFinite(retentionDays) ? Math.min(Math.max(retentionDays, 1), 3650) : 30,
+    maxEntries: Number.isFinite(maxEntries) ? Math.min(Math.max(maxEntries, 1), 10000) : 200,
+  };
+}
+
 export async function loadRedactionVaultOrDefault() {
   try {
-    return await readJson(getRedactionVaultPath());
+    const vault = await readJson(getRedactionVaultPath());
+    const normalized = applyRedactionVaultPolicy(vault);
+    if (JSON.stringify(vault) !== JSON.stringify(normalized)) {
+      await saveRedactionVault(normalized);
+    }
+    return normalized;
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       return createDefaultVault();
@@ -47,15 +68,75 @@ export async function loadRedactionVaultOrDefault() {
 }
 
 export async function seedRedactionVault() {
+  const vaultPath = getRedactionVaultPath();
   await writeFileIfMissing(
-    getRedactionVaultPath(),
-    `${JSON.stringify(createDefaultVault(), null, 2)}\n`,
+    vaultPath,
+    `${JSON.stringify(applyRedactionVaultPolicy(createDefaultVault()), null, 2)}\n`,
   );
+  await secureRedactionVaultPermissions(vaultPath);
 }
 
 export async function saveRedactionVault(vault) {
-  await writeJson(getRedactionVaultPath(), vault);
-  return vault;
+  const normalized = applyRedactionVaultPolicy(vault);
+  const vaultPath = getRedactionVaultPath();
+  await writeJson(vaultPath, normalized);
+  await secureRedactionVaultPermissions(vaultPath);
+  return normalized;
+}
+
+async function secureRedactionVaultPermissions(vaultPath) {
+  const directory = path.dirname(vaultPath);
+  await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+  await fs.chmod(directory, 0o700);
+  await fs.chmod(vaultPath, 0o600);
+}
+
+export async function inspectRedactionVault() {
+  const vaultPath = getRedactionVaultPath();
+  try {
+    const [file, directory] = await Promise.all([
+      fs.stat(vaultPath),
+      fs.stat(path.dirname(vaultPath)),
+    ]);
+    const fileMode = file.mode & 0o777;
+    const directoryMode = directory.mode & 0o777;
+    const issues = [];
+    if (fileMode !== 0o600) issues.push(`vault file mode ${fileMode.toString(8)}; expected 600`);
+    if (directoryMode !== 0o700) {
+      issues.push(`vault directory mode ${directoryMode.toString(8)}; expected 700`);
+    }
+    return {
+      exists: true,
+      path: vaultPath,
+      status: issues.length > 0 ? "warning" : "ok",
+      issues,
+      policy: getRedactionVaultPolicy(),
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {
+        exists: false,
+        path: vaultPath,
+        status: "ok",
+        issues: [],
+        policy: getRedactionVaultPolicy(),
+      };
+    }
+    throw error;
+  }
+}
+
+export async function purgeRedactionVault({ dryRun = false } = {}) {
+  const vaultPath = getRedactionVaultPath();
+  const exists = await fs
+    .stat(vaultPath)
+    .then(() => true)
+    .catch((error) => {
+      if (error?.code === "ENOENT") return false;
+      throw error;
+    });
+  if (exists && !dryRun) await fs.rm(vaultPath, { force: true });
+  return { status: exists ? (dryRun ? "would-purge" : "purged") : "absent", path: vaultPath };
 }
 
 async function appendRedactionEvent({ replacementCount, metadata }) {
@@ -67,7 +148,7 @@ async function appendRedactionEvent({ replacementCount, metadata }) {
   });
 }
 
-export function maskSensitiveText(rawText) {
+function maskSensitiveTextInternal(rawText) {
   let sanitizedText = rawText;
   const replacements = [];
   const seen = new Set();
@@ -89,19 +170,27 @@ export function maskSensitiveText(rawText) {
   }
 
   return {
-    sanitizedText,
+    sanitizedText: redactPreviewPaths(sanitizedText),
     replacements,
   };
 }
 
+export function maskSensitiveText(rawText) {
+  const result = maskSensitiveTextInternal(rawText);
+  return {
+    sanitizedText: result.sanitizedText,
+    replacements: result.replacements.map(publicReplacement),
+  };
+}
+
 export async function redactProviderBoundText(rawText, metadata = {}) {
   const vault = await loadRedactionVaultOrDefault();
-  const { sanitizedText, replacements } = maskSensitiveText(rawText);
+  const { sanitizedText, replacements } = maskSensitiveTextInternal(rawText);
 
   if (replacements.length === 0) {
     return {
       sanitizedText,
-      replacements,
+      replacements: replacements.map(publicReplacement),
     };
   }
 
@@ -118,34 +207,107 @@ export async function redactProviderBoundText(rawText, metadata = {}) {
   await appendRedactionEvent({ replacementCount: replacements.length, metadata });
   return {
     sanitizedText,
-    replacements,
+    replacements: replacements.map(publicReplacement),
   };
 }
 
-function redactPayloadValue(value, replacements) {
+function redactPayloadValue(value, replacements, seen = new WeakSet()) {
   if (typeof value === "string") {
-    const result = maskSensitiveText(value);
+    const result = maskSensitiveTextInternal(value);
     replacements.push(...result.replacements);
-    return result.sanitizedText;
+    return redactPreviewPaths(result.sanitizedText);
   }
 
   if (Array.isArray(value)) {
-    return value.map((item) => redactPayloadValue(item, replacements));
+    return redactObjectValue(value, replacements, seen);
   }
 
   if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [key, redactPayloadValue(entry, replacements)]),
-    );
+    return redactObjectValue(value, replacements, seen);
   }
 
   return value;
 }
 
+function filterPublicValue(value, classes, seen = new WeakSet()) {
+  if (typeof value === "string") {
+    if (/(?:[A-Za-z]:\\|\/(?:Users|home|tmp|var|etc|opt|srv|mnt|private)[\\/])/.test(value)) {
+      classes.add("local_path");
+    }
+    return { value, omitted: false };
+  }
+  if (!value || typeof value !== "object") return { value, omitted: false };
+  if (
+    ["personal/local", "user-local", "session-only"].includes(value.scope) ||
+    (value.freshness?.status === "stale" && !value.provenance && !value.sourceFiles)
+  ) {
+    classes.add(value.scope ? "private_context" : "stale_without_provenance");
+    return { value: undefined, omitted: true };
+  }
+  if (seen.has(value)) return { value: "[Circular]", omitted: false };
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value
+      .map((item) => filterPublicValue(item, classes, seen))
+      .filter((item) => !item.omitted)
+      .map((item) => item.value);
+    seen.delete(value);
+    return { value: result, omitted: false };
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const filtered = filterPublicValue(entry, classes, seen);
+    if (!filtered.omitted) result[key] = filtered.value;
+  }
+  seen.delete(value);
+  return { value: result, omitted: false };
+}
+
+function redactObjectValue(value, replacements, seen) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    const result = value.map((item) =>
+      typeof item === "string"
+        ? redactPayloadValue(item, replacements, seen)
+        : redactObjectValue(item, replacements, seen),
+    );
+    seen.delete(value);
+    return result;
+  }
+
+  const result = Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => {
+      const redactedEntry =
+        typeof entry === "string"
+          ? redactPayloadValue(entry, replacements, seen)
+          : redactObjectValue(entry, replacements, seen);
+      if (typeof redactedEntry === "string" && /(?:preview|excerpt|snippet|path|file)/i.test(key)) {
+        return [key, redactPreviewPaths(redactedEntry)];
+      }
+      return [key, redactedEntry];
+    }),
+  );
+  seen.delete(value);
+  return result;
+}
+
+function publicReplacement({ placeholder, placeholderBase }) {
+  return { placeholder, placeholderBase };
+}
+
 export async function redactProviderBoundPayload(payload, metadata = {}) {
   const vault = await loadRedactionVaultOrDefault();
   const replacements = [];
-  const sanitizedPayload = redactPayloadValue(payload, replacements);
+  const classes = new Set();
+  const filtered = filterPublicValue(payload, classes).value;
+  const sanitizedPayload = redactPayloadValue(filtered, replacements);
 
   for (const replacement of replacements) {
     vault.entries[replacement.placeholder] = {
@@ -163,12 +325,49 @@ export async function redactProviderBoundPayload(payload, metadata = {}) {
 
   return {
     sanitizedPayload,
-    replacements,
+    replacements: replacements.map(publicReplacement),
     redaction_receipt: {
       record_type: "redaction_receipt",
       replacement_count: replacements.length,
       provider_safe: true,
       raw_values_stored_locally: replacements.length > 0,
+      redacted_classes: [
+        ...classes,
+        ...new Set(replacements.map((replacement) => replacement.placeholderBase)),
+      ],
+    },
+  };
+}
+
+function redactPreviewPaths(value) {
+  return value.replace(
+    /(?:[A-Za-z]:\\|\/(?:Users|home|tmp|var|etc|opt|srv|mnt|private)[\\/])(?:[A-Za-z0-9._ -]+[\\/])+[A-Za-z0-9._ -]+(?:\.[A-Za-z0-9._ -]+)?/g,
+    "__MA_PATH_REDACTED__",
+  );
+}
+
+function applyRedactionVaultPolicy(vault) {
+  const entries = Object.entries(vault?.entries ?? {});
+  entries.sort((left, right) => {
+    const leftTime = Date.parse(left[1]?.createdAt ?? "") || 0;
+    const rightTime = Date.parse(right[1]?.createdAt ?? "") || 0;
+    return rightTime - leftTime;
+  });
+
+  const policy = getRedactionVaultPolicy();
+  const cutoff = Date.now() - policy.retentionDays * 24 * 60 * 60 * 1000;
+  const retainedEntries = entries.filter(([, entry]) => {
+    const createdAt = Date.parse(entry?.createdAt ?? "") || 0;
+    return createdAt >= cutoff;
+  });
+
+  const limitedEntries = retainedEntries.slice(0, policy.maxEntries);
+  return {
+    ...vault,
+    policy: {
+      retention_days: policy.retentionDays,
+      max_entries: policy.maxEntries,
     },
+    entries: Object.fromEntries(limitedEntries),
   };
 }

package/src/runtime/runtime-state.js

@@ -3,7 +3,10 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { readJson, writeJson } from "../fs-utils.js";
 import { getRepoRoot, getRuntimeReadPath } from "../paths.js";
-import { summarizeReleaseIssueGateStatus } from "../release-issue-gates.js";
+import {
+  resolveReleaseIssueGates,
+  summarizeReleaseIssueGateStatus,
+} from "../release-issue-gates.js";
 import { createDefaultReleaseState, validateReleaseState } from "../release-state.js";
 import {
   createDefaultActiveAutonomyCore,
@@ -13,18 +16,29 @@ import {
 } from "./active-autonomy-core.js";
 import { seedAlignmentSentinelArtifacts } from "./alignment-sentinel.js";
 import { seedArchitectReviewArtifacts } from "./architect-review.js";
+import { seedAutonomousTaskArtifacts } from "./autonomous-tasks.js";
 import {
   createDefaultCodeGraphRehearse,
   getCodeGraphRehearsePath,
   seedCodeGraphRehearseArtifacts,
   validateCodeGraphRehearse,
 } from "./code-graph-rehearse.js";
+import {
+  createDefaultCodeburnUsage,
+  getCodeburnLogPath,
+  seedCodeburnArtifacts,
+} from "./codeburn-core.js";
 import {
   createDefaultContextEconomyCore,
   getContextEconomyCorePath,
   seedContextEconomyCoreArtifacts,
   validateContextEconomyCore,
 } from "./context-economy-core.js";
+import {
+  createDefaultContinuityGraph,
+  getContinuityGraphPath,
+  validateContinuityGraph,
+} from "./continuity-graph.js";
 import {
   getContinuityIndexPath,
   getContinuityNotesPath,
@@ -42,11 +56,18 @@ import {
   seedEnvironmentAwarenessCoreArtifacts,
   validateEnvironmentAwarenessCore,
 } from "./environment-awareness-core.js";
+import {
+  createDefaultGraphifyIndex,
+  getGraphifyIndexPath,
+  seedGraphifyArtifacts,
+  validateGraphifyIndex,
+} from "./graphify-core.js";
 import {
   getGuidanceIncludeGraphPath,
   getMergedGuidancePath,
   seedGuidanceStackArtifacts,
 } from "./guidance-stack.js";
+import { seedHeadroomArtifacts } from "./headroom-core.js";
 import {
   createDefaultHelperOrchestrationCore,
   getHelperOrchestrationCorePath,
@@ -137,9 +158,11 @@ import { getWorkspacesIndexPath, seedWorkspaceArtifacts } from "./workspaces.js"
 
 const runtimeSubsystemSeeders = [
   seedGuidanceStackArtifacts,
+  seedGraphifyArtifacts,
   seedContinuityArtifacts,
   seedSignalHookArtifacts,
   seedOrchestratorArtifacts,
+  seedAutonomousTaskArtifacts,
   seedWorkspaceArtifacts,
   seedMaestroManagerArtifacts,
   seedMaestroStateArtifacts,
@@ -147,6 +170,7 @@ const runtimeSubsystemSeeders = [
   seedAlignmentSentinelArtifacts,
   seedSemanticRecordingCoreArtifacts,
   seedHelperOrchestrationCoreArtifacts,
+  seedHeadroomArtifacts,
   seedLearningLoopCoreArtifacts,
   seedWorkspaceIntelligenceArtifacts,
   seedPromptStrategyCoreArtifacts,
@@ -158,6 +182,7 @@ const runtimeSubsystemSeeders = [
   seedObsidianBridgeArtifacts,
   seedWorkspaceVirtualizerArtifacts,
   seedCodeGraphRehearseArtifacts,
+  seedCodeburnArtifacts,
   seedSkillsRegistryExportArtifacts,
 ];
 const defaultMergedGuidance = {
@@ -256,11 +281,13 @@ const defaultObsidianVaultIndex = createDefaultObsidianVaultIndex();
 const defaultObsidianVaultOperations = createDefaultObsidianVaultOperations();
 const defaultWorkspaceVirtualizer = createDefaultWorkspaceVirtualizer();
 const defaultCodeGraphRehearse = createDefaultCodeGraphRehearse();
+const defaultCodeburnUsage = createDefaultCodeburnUsage();
 const defaultSkillsRegistryExport = createDefaultSkillsRegistryExport();
 const defaultCapabilityComposition = createDefaultCapabilityComposition();
 const defaultWorkspaceContextPack = createDefaultWorkspaceContextPack();
 const defaultWorkspaceEffectiveness = createDefaultWorkspaceEffectiveness();
 const defaultSemanticReceiptIndex = createDefaultSemanticReceiptIndex();
+const defaultContinuityGraph = createDefaultContinuityGraph();
 const terminalManagerStates = new Set(["completed", "blocked", "failed", "cancelled"]);
 const repairableRuntimeArtifacts = new Set([
   "guidance.merged",
@@ -284,6 +311,7 @@ const repairableRuntimeArtifacts = new Set([
   "context.workspaceEffectiveness",
   "evidence.semanticReceipts",
   "memory.index",
+  "memory.graph",
   "hooks.config",
   "tasks.registry",
   "workspaces.index",
@@ -418,11 +446,17 @@ export async function loadRuntimeSnapshot() {
   await fs.access(getTaskLockRoot()).catch(() => {
     missingArtifacts.push("tasks.locks");
   });
+  const releaseIssueGatesResolution = resolveReleaseIssueGates(getRepoRoot());
+  if (!releaseIssueGatesResolution) {
+    missingArtifacts.push("release.issueGates");
+  }
 
   const [
     mergedGuidance,
     guidanceGraph,
+    graphifyIndex,
     continuityIndex,
+    continuityGraph,
     continuityNotes,
     hookConfig,
     taskRegistry,
@@ -448,6 +482,7 @@ export async function loadRuntimeSnapshot() {
     obsidianVaultOperations,
     workspaceVirtualizer,
     codeGraphRehearse,
+    codeburnUsage,
     skillsRegistryExport,
     capabilityComposition,
     workspaceContextPack,
@@ -460,7 +495,9 @@ export async function loadRuntimeSnapshot() {
       defaultGuidanceGraph,
       "guidance.includeGraph",
     ),
+    readJsonWithStatus(getGraphifyIndexPath(), createDefaultGraphifyIndex(), "context.graphify"),
     readJsonWithStatus(getContinuityIndexPath(), defaultContinuityIndex, "memory.index"),
+    readJsonWithStatus(getContinuityGraphPath(), defaultContinuityGraph, "memory.graph"),
     readTextWithStatus(getContinuityNotesPath(), "", "memory.notes"),
     readJsonWithStatus(getRuntimeHooksConfigPath(), defaultHookConfig, "hooks.config"),
     readJsonWithStatus(getTaskRegistryPath(), defaultTaskRegistry, "tasks.registry"),
@@ -488,7 +525,8 @@ export async function loadRuntimeSnapshot() {
     ),
     readJsonWithStatus(getRuntimeReadPath("evidence", "cves.json"), defaultCves, "runtime.cves"),
     readJsonWithStatus(
-      path.join(getRepoRoot(), "docs", "qa", "release-issue-gates-0.1.13.json"),
+      releaseIssueGatesResolution?.path ??
+        path.join(getRepoRoot(), "docs", "qa", "release-issue-gates-missing.json"),
       defaultReleaseIssueGates,
       "release.issueGates",
     ),
@@ -560,6 +598,7 @@ export async function loadRuntimeSnapshot() {
       defaultCodeGraphRehearse,
       "context.codeGraphRehearse",
     ),
+    readJsonWithStatus(getCodeburnLogPath(), defaultCodeburnUsage, "context.codeburnUsage"),
     readJsonWithStatus(
       getSkillsRegistryExportPath(),
       defaultSkillsRegistryExport,
@@ -608,6 +647,20 @@ export async function loadRuntimeSnapshot() {
       Array.isArray(value.edges),
     invalidArtifacts,
   );
+  const validatedGraphifyIndex = coerceValidated(
+    graphifyIndex,
+    createDefaultGraphifyIndex(),
+    "context.graphify",
+    (value) => {
+      try {
+        validateGraphifyIndex(value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    invalidArtifacts,
+  );
   const validatedContinuityIndex = coerceValidated(
     continuityIndex,
     defaultContinuityIndex,
@@ -619,6 +672,20 @@ export async function loadRuntimeSnapshot() {
       "lastUpdatedAt" in value,
     invalidArtifacts,
   );
+  const validatedContinuityGraph = coerceValidated(
+    continuityGraph,
+    defaultContinuityGraph,
+    "memory.graph",
+    (value) => {
+      try {
+        validateContinuityGraph(value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    invalidArtifacts,
+  );
   const validatedHookConfig = coerceValidated(
     hookConfig,
     defaultHookConfig,
@@ -895,6 +962,19 @@ export async function loadRuntimeSnapshot() {
     },
     invalidArtifacts,
   );
+  const validatedCodeburnUsage = coerceValidated(
+    codeburnUsage,
+    defaultCodeburnUsage,
+    "context.codeburnUsage",
+    (value) =>
+      value &&
+      typeof value === "object" &&
+      value.schemaVersion === defaultCodeburnUsage.schemaVersion &&
+      Array.isArray(value.entries) &&
+      Number.isFinite(value.totalTokens) &&
+      Number.isFinite(value.totalCost),
+    invalidArtifacts,
+  );
   const validatedSkillsRegistryExport = coerceValidated(
     skillsRegistryExport,
     defaultSkillsRegistryExport,
@@ -969,7 +1049,9 @@ export async function loadRuntimeSnapshot() {
   return {
     mergedGuidance: validatedMergedGuidance,
     guidanceGraph: validatedGuidanceGraph,
+    graphifyIndex: validatedGraphifyIndex,
     continuityIndex: validatedContinuityIndex,
+    continuityGraph: validatedContinuityGraph,
     continuityNotes,
     hookConfig: validatedHookConfig,
     taskRegistry: validatedTaskRegistry,
@@ -980,6 +1062,7 @@ export async function loadRuntimeSnapshot() {
     audits: validatedAudits,
     cves: validatedCves,
     releaseIssueGateStatus,
+    releaseIssueGatesSource: releaseIssueGatesResolution,
     managerRuns: validatedManagerRuns,
     maestroState: validatedMaestroState,
     activeAutonomyCore: validatedActiveAutonomyCore,
@@ -996,6 +1079,7 @@ export async function loadRuntimeSnapshot() {
     obsidianVaultOperations: validatedObsidianVaultOperations,
     workspaceVirtualizer: validatedWorkspaceVirtualizer,
     codeGraphRehearse: validatedCodeGraphRehearse,
+    codeburnUsage: validatedCodeburnUsage,
     skillsRegistryExport: validatedSkillsRegistryExport,
     capabilityComposition: validatedCapabilityComposition,
     workspaceContextPack: validatedWorkspaceContextPack,
@@ -1021,6 +1105,9 @@ export function createRuntimeSummary(snapshot) {
   return {
     guidanceSourceCount: snapshot.mergedGuidance.sources.length,
     guidanceIncludeRoots: snapshot.guidanceGraph.roots.length,
+    graphNodeCount: snapshot.graphifyIndex.nodes.length,
+    graphEdgeCount: snapshot.graphifyIndex.edges.length,
+    graphLastRebuiltAt: snapshot.graphifyIndex.lastRebuiltAt,
     continuitySessionCount: snapshot.continuityIndex.sessionCount,
     continuityHasNotes:
       trimmedNotes.length > 0 &&
@@ -1103,6 +1190,8 @@ export function createRuntimeSummary(snapshot) {
     codeGraphRehearseSourceMutationAllowed:
       snapshot.codeGraphRehearse.mutation_policy.may_mutate_source,
     codeGraphRehearseMaxSteps: snapshot.codeGraphRehearse.max_steps,
+    tokenUsage: snapshot.codeburnUsage.totalTokens,
+    estimatedCost: snapshot.codeburnUsage.totalCost,
     skillsRegistryCanonicalDir: snapshot.skillsRegistryExport.canonical_dir,
     skillsRegistryReleaseMutationAllowed:
       snapshot.skillsRegistryExport.authority_boundary.exported_payloads_may_mutate_release_state,
@@ -1199,6 +1288,9 @@ export async function repairRuntimeScratchpadArtifacts(artifactLabels = []) {
       case "memory.index":
         await writeJson(getContinuityIndexPath(), defaultContinuityIndex);
         break;
+      case "memory.graph":
+        await writeJson(getContinuityGraphPath(), defaultContinuityGraph);
+        break;
       case "hooks.config":
         await writeJson(getRuntimeHooksConfigPath(), defaultHookConfig);
         break;