@dotdotgod/claude-code 0.6.4 → 0.6.6

package/README.md

@@ -76,7 +76,7 @@ Projects can customize memory roles with `memory.areas`, select traceability-enf
 
 ## Bundled MCP And Hooks
 
-The plugin starts a local stdio MCP server. It exposes `execute` and `execute_file`; context index, search, fetch, session resume, durable ingestion-job lifecycle, explicit healing, stats, doctor, and purge tools; plus `dotdotgod_project_load`, `dotdotgod_project_impact`, and `dotdotgod_project_initialize`.
+The plugin starts a local stdio MCP server. It exposes `execute` and `execute_file`; context index, search, fetch, session resume, durable ingestion-job lifecycle, explicit healing, stats, doctor, and purge tools; plus `project_load`, `project_impact`, `impact_status`, `project_initialize`, `embedding_status`, and confirmation-gated `embedding_install`. Individual names have no `dotdotgod_` prefix; discover the host-qualified names. Reload existing sessions after upgrading; legacy names are not aliases.
 
 Dotdotgod execution tools share a 10 MiB stdout/stderr capture ceiling per command. Crossing that ceiling terminates the child process and reports `captureLimitExceeded`; direct stdout and stderr excerpts are each capped at 1 MiB. Their child environments preserve compatibility-oriented inheritance after filtering runtime injection variables; this reports filtered names without values but does not isolate ordinary inherited credentials. Large output is indexed before retrieval in the ignored project-local `.dotdotgod/context/context.sqlite` FTS5 store, and searches return bounded excerpts. The store uses WAL, a bounded busy timeout, and transactional source replacement, expiry, and purge. Structural Markdown/JSON chunks, bounded typo-tolerant trigram candidates, reciprocal-rank fusion, and title/path/proximity signals improve retrieval while provenance and `instructionAuthority: "none"` identify retrieved text as non-authoritative data.
 
@@ -84,6 +84,16 @@ The MCP `index` tool accepts files or explicitly requested bounded directories,
 
 Bundled hooks mark project load as required at session start, record successful source/config edits, and deny broad verification or handoff commands until matching graph impact succeeds. Denial asks Claude to call the required MCP tool and retry; hooks do not silently change one tool type into another. See [`hooks/README.md`](https://github.com/dotdotgod/dotdotgod-kit/blob/main/packages/claude-code/hooks/README.md) for lifecycle and trust boundaries.
 
+## Native Plan Directory
+
+After opting in, run `dotdotgod init . --claude-plans --dry-run`, then repeat
+without `--dry-run` to add project `.claude/settings.json` `plansDirectory`.
+Use `node <plugin>/mcp/cli.mjs init . --claude-plans` if the CLI is unavailable.
+Existing values and other settings are preserved; global settings and permissions
+are untouched. Native filenames remain Claude Code-owned, while shared task plans
+use `docs/plan/<task-slug>/README.md` when the mode permits. No Mods are required.
+Actual native storage was verified on Claude Code 2.1.308 with an offline fixture.
+
 ## Local Development
 
 ```bash

package/commands/dd/init.md

@@ -1,6 +1,6 @@
 ---
 description: Initialize dotdotgod project memory and config
-argument-hint: [project-root] [--dotdot-setting] [--dry-run]
+argument-hint: [project-root] [--dotdot-setting] [--claude-plans] [--dry-run]
 allowed-tools: [Read, Glob, Grep, Bash, Write, Edit]
 ---
 
@@ -38,3 +38,8 @@ Create a non-destructive dotdotgod baseline with canonical agent instructions, t
 3. The POSIX fallback supports bundled templates only. If a custom template was selected and the CLI is unavailable, stop and explain that custom templates require the CLI; do not silently substitute another template.
 4. Validate the initialized project with `dotdotgod validate <project-root>` when available.
 5. Report created and skipped files, the selected template, validation failures, and unresolved instruction conflicts.
+
+
+## Native Plan Storage
+
+Only after the user opts in, add `--claude-plans` to the CLI initialization command. It adds project-local `plansDirectory` without replacing an existing value or changing permissions. Preview with `--dry-run`. The shell fallback does not support this option: use the bundled CLI at `$CLAUDE_PLUGIN_ROOT/mcp/cli.mjs` instead. Native file names remain Claude Code-owned; shared task plans still use task directories and README.md.

package/commands/dd/plan.md

@@ -16,6 +16,10 @@ Task request: `$ARGUMENTS`
 
 For focused documentation routing, run `dotdotgod query <root> "<focus>" --limit 30 --json`. Run `dotdotgod config <root> --json` when memory-area policy or documentation routing/exclusions affect the plan. If the CLI is unavailable, continue from README indexes and focused file reads.
 
+## Native Plan Mode
+
+Claude Code owns its native plan file and naming. An opt-in plansDirectory setting can place native files under the project documentation plan directory; it does not grant arbitrary task README writes in native Plan Mode. Follow the native allowed path and permissions. Create the shared task README when the active mode permits it; never bypass restrictions through MCP or hooks.
+
 ## Goal
 
 Create an implementation plan from maintained repository documentation before substantial source or configuration changes.
@@ -28,7 +32,7 @@ Use `docs/plan/<task-slug>/README.md` for substantial, risky, or resumable work;
 2. Reuse loaded memory and the documentation map, then use focused query and README indexes to select maintained docs and verify conclusions in them.
 3. Inspect the source needed to confirm targets and constraints.
 4. Run impact review on likely changed files and refine targets, risks, and verification.
-5. For durable work, write and present the task README with scope, targets, executable steps, verification, and required completion gates.
+5. When the active mode and permissions allow it, write and present the task README with scope, targets, executable steps, verification, and required completion gates.
 6. Resolve blocking decisions and stop until the user asks to execute the plan.
 
 ## Quality Rules

package/hooks/README.md

@@ -2,6 +2,11 @@
 
 ## Packaged Defaults
 
+Local planning Markdown under the configured documentation plan directory does
+not create source-impact pending state. Native plan paths and permissions remain
+host-owned; hooks do not grant plan writes. Hook runtime state and MCP caches
+have separate process permissions from the model's native tools.
+
 The adapter packages `hooks/hooks.json` and `hooks/runtime.mjs`. They inject a bounded project-load requirement at session start, record successful `Edit`/`Write` paths, and deny broad verification or handoff shell commands while graph impact is pending. A denial names the required dotdotgod MCP tool; Claude calls it and retries the original operation. MCP tools bypass their own guards to prevent recursion.
 
 Runtime state is local to `.dotdotgod/context/runtime/`. A successful impact call clears only paths whose current fingerprints match recorded edit state. Hooks run local commands with user permissions; review plugin resources before enabling them.

package/hooks/runtime.mjs

@@ -90,7 +90,12 @@ function toolInput(input) {
   return input.tool_input || input.toolInput || {};
 }
 function mcpTool(name, suffix) {
-  return name === suffix || name.endsWith(`__${suffix}`) || name.endsWith(`_${suffix}`);
+  return name === suffix || [
+    "mcp__dotdotgod_context__",
+    "mcp__dotdotgod-context__",
+    "mcp__plugin_dotdotgod_dotdotgod-context__",
+    "mcp__plugin_dotdotgod_dotdotgod_context__"
+  ].some((prefix) => name === `${prefix}${suffix}`);
 }
 function deny(reason) {
   return { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } };
@@ -111,6 +116,16 @@ function changedPath(input, root) {
   const path = value.file_path || value.path;
   return normalizeProjectPath(root, path);
 }
+function isPlanDocument(root, path) {
+  let documentationRoot = "docs";
+  try {
+    const config = JSON.parse(readFileSync(join(root, "dotdotgod.config.json"), "utf8"));
+    if (typeof config.documentation?.root === "string") documentationRoot = config.documentation.root;
+  } catch {
+  }
+  const plan = normalizeProjectPath(root, join(documentationRoot, "plan"));
+  return plan && isInsideRoot(plan, path) && /\.md$/i.test(path);
+}
 function hasFailedToolResult(input) {
   const response = input.tool_response || input.toolResponse || input.tool_result || input.toolResult || input.result;
   if (!response || typeof response !== "object") return false;
@@ -132,19 +147,19 @@ function runHook(event) {
     if (!context) return {};
     state.loadRequired = true;
     writeState(context.path, state);
-    return { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: "Dotdotgod project memory has not been loaded for this session. Before substantive shell or write work, call dotdotgod_project_load once with a concise task-specific focus." } };
+    return { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: "Dotdotgod project memory has not been loaded for this session. Before substantive shell or write work, call project_load from the dotdotgod-context MCP server once with a concise task-specific focus." } };
   }
   if (event === "pretooluse") {
-    if (mcpTool(name, "dotdotgod_project_load") || mcpTool(name, "dotdotgod_project_impact")) return {};
-    if (state.loadRequired && isSubstantive(name)) return deny("Project memory is required first. Call dotdotgod_project_load with the current project root and a concise task-specific focus, then retry this tool.");
+    if (mcpTool(name, "project_load") || mcpTool(name, "project_impact")) return {};
+    if (state.loadRequired && isSubstantive(name)) return deny("Project memory is required first. Call project_load from the dotdotgod-context MCP server with the current project root and a concise task-specific focus, then retry this tool.");
     const pendingPaths = Object.keys(state.pending);
-    if (pendingPaths.length && isImpactGate(name, input)) return deny(`Graph impact is pending. Call dotdotgod_project_impact with paths=${JSON.stringify(pendingPaths)} and then retry this tool.`);
+    if (pendingPaths.length && isImpactGate(name, input)) return deny(`Graph impact is pending. Call project_impact from the dotdotgod-context MCP server with paths=${JSON.stringify(pendingPaths)} and then retry this tool.`);
     return {};
   }
   if (event === "posttooluse") {
     if (!context) return {};
-    if (mcpTool(name, "dotdotgod_project_load")) state.loadRequired = false;
-    else if (mcpTool(name, "dotdotgod_project_impact")) {
+    if (mcpTool(name, "project_load")) state.loadRequired = false;
+    else if (mcpTool(name, "project_impact")) {
       const checked = toolInput(input).paths;
       let cleared = 0;
       if (Array.isArray(checked)) for (const path of checked) {
@@ -155,11 +170,11 @@ function runHook(event) {
         }
       }
       writeState(context.path, state);
-      if (cleared > 0 && hasFailedToolResult(input)) return { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: `dotdotgod_project_impact reported a failure, but dotdotgod cleared pending graph impact for ${cleared} requested path(s) to avoid a blocking retry loop. Review the impact error before broad operations.` } };
+      if (cleared > 0 && hasFailedToolResult(input)) return { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: `project_impact reported a failure, but dotdotgod cleared pending graph impact for ${cleared} requested path(s) to avoid a blocking retry loop. Review the impact error before broad operations.` } };
       return {};
     } else if (/^(Edit|Write|apply_patch)$/i.test(name)) {
       const path = changedPath(input, context.root);
-      if (path) state.pending[path] = fileHash(path);
+      if (path && !isPlanDocument(context.root, path)) state.pending[path] = fileHash(path);
     }
     writeState(context.path, state);
     return {};