@kaddo/cli 3.11.2 → 3.12.0

package/dist/index.js

@@ -2249,6 +2249,12 @@ You do **not** suggest branches, commits or pull requests \u2014 implementation
 branch suggestion) is the implementation-agent's responsibility, and only by respecting the
 project Git strategy. Your job ends at a clear, traceable Work Item.
 
+## Git boundaries
+
+Never run Git. Do not create or switch branches, create worktrees, stash, commit, push or merge.
+Work only inside the currently selected workspace. If a workspace or branch change is required,
+stop and ask the human.
+
 ## Quality Checklist
 
 - The problem is one clear sentence.
@@ -2814,6 +2820,10 @@ Conventional Commit message \u2014 as suggestions, never executed.
 ## Constraints
 
 - Never run Git. Never commit, push or merge \u2014 suggest and wait for the human.
+- **Do not create branches, switch branches, create worktrees, or stash changes.** You may
+  *suggest* a branch name; the human creates the branch and selects the workspace.
+- **Work only inside the currently selected workspace** (repository root or the active Git
+  worktree). If a branch or workspace change is required, stop and ask the human.
 - Respect \`knowledge/tech/git-strategy.md\` when it exists.
 - Keep knowledge in sync with the code you change.
 - Do not invent business facts.
@@ -4959,6 +4969,42 @@ function assessPhase(input) {
   return { phase, reasons, recommendedAgents: recommendedAgents2, nextStep };
 }
 
+// src/core/workspace.ts
+import { dirname, resolve, basename } from "path";
+function findGitEntry(startDir) {
+  let cur = resolve(startDir);
+  while (true) {
+    const g = join(cur, ".git");
+    if (exists(g)) return { dir: cur, gitPath: g };
+    const parent = dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+function readBranch(gitDir) {
+  try {
+    const head = readFile(join(gitDir, "HEAD")).trim();
+    const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+    if (m) return m[1].trim();
+    return head ? head.slice(0, 12) : null;
+  } catch {
+    return null;
+  }
+}
+function detectWorkspace(startDir) {
+  const found = findGitEntry(startDir);
+  if (!found) return { isGitRepo: false, root: null, branch: null, isWorktree: false };
+  const { dir, gitPath } = found;
+  if (!isFile(gitPath)) {
+    return { isGitRepo: true, root: dir, branch: readBranch(gitPath), isWorktree: false };
+  }
+  let gitDir = gitPath;
+  const m = readFile(gitPath).match(/gitdir:\s*(.+)/);
+  if (m) gitDir = m[1].trim();
+  const isWorktree = basename(dirname(gitDir)) === "worktrees";
+  return { isGitRepo: true, root: dir, branch: readBranch(gitDir), isWorktree };
+}
+
 // src/core/knowledge-discovery.ts
 var KNOWLEDGE = "knowledge";
 var CONSOLIDATED_TYPE = {
@@ -5008,7 +5054,7 @@ function layerFromPath(filePath) {
   if (p2.includes(`/${KNOWLEDGE}/delivery/`)) return "Delivery";
   return null;
 }
-function basename(p2) {
+function basename2(p2) {
   return p2.replace(/\\/g, "/").split("/").pop() ?? p2;
 }
 function discoverLayers(dir) {
@@ -5025,9 +5071,9 @@ function discoverLayers(dir) {
     const layer2 = layerForType(type) ?? layerFromPath(a.filePath);
     if (!layer2) continue;
     const slot = acc[layer2];
-    slot.detected.add(basename(a.filePath));
+    slot.detected.add(basename2(a.filePath));
     if (layer2 === "Delivery") {
-      if (type === "roadmap" || basename(a.filePath) === "roadmap.md") slot.hasRoadmap = true;
+      if (type === "roadmap" || basename2(a.filePath) === "roadmap.md") slot.hasRoadmap = true;
       if (WORK_ITEM_TYPES2.has(type) || a.filePath.replace(/\\/g, "/").includes("/delivery/work-items/")) {
         if (a.filePath.replace(/\\/g, "/").includes("/delivery/work-items/")) slot.hasWorkItem = true;
       }
@@ -5210,6 +5256,7 @@ function buildProjectExplanation(dir) {
     workItemsMissingOwnership: items.length - withOwnership
   };
   const domains = [...new Set(workItemArtifacts.flatMap((a) => a.domains))].filter(Boolean);
+  const workspace = detectWorkspace(dir);
   const roadmapPath = join(dir, ARCH_DIR4, "delivery", "roadmap.md");
   const roadmapMd = exists(roadmapPath) ? readFile(roadmapPath) : null;
   const roadmap = roadmapStats(roadmapMd, items.length);
@@ -5259,6 +5306,7 @@ function buildProjectExplanation(dir) {
     workItems,
     ownership,
     domains,
+    workspace,
     layers,
     roadmap,
     mappedModules,
@@ -5291,6 +5339,21 @@ function renderExplanationHuman(exp) {
   lines.push(`- Team: ${exp.project.teamSize}`);
   lines.push(`- Structure: ${exp.project.structure}`);
   lines.push("");
+  lines.push("## Workspace");
+  if (exp.workspace.isGitRepo) {
+    lines.push(`- Repository root: ${exp.workspace.root ?? "unknown"}`);
+    lines.push(`- Git worktree: ${exp.workspace.isWorktree ? "yes" : "no"}`);
+    lines.push(`- Active branch: ${exp.workspace.branch ?? "unknown"}`);
+    if (exp.workspace.isWorktree) {
+      lines.push("");
+      lines.push(
+        "> Worktree detected. Run all Kaddo commands (scan, guard, owners suggest, explain) from this worktree while implementation is active, so they observe the same files the agent is changing."
+      );
+    }
+  } else {
+    lines.push("- Not a Git repository");
+  }
+  lines.push("");
   lines.push("## Knowledge Layers");
   lines.push(renderLayersMarkdown(exp.layers));
   lines.push("");
@@ -5781,6 +5844,7 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
     layers,
     roadmap,
     phase,
+    workspace: detectWorkspace(dir),
     deliveryMix,
     mappedModules,
     missing,
@@ -5818,6 +5882,23 @@ function renderContextPack(pack) {
       `- Structure: ${project.structure}`
     ].join("\n") + "\n"
   );
+  parts.push("## Execution Context\n");
+  if (pack.workspace.isGitRepo) {
+    parts.push(
+      [
+        `- Repository root: ${pack.workspace.root ?? "unknown"}`,
+        `- Current branch: ${pack.workspace.branch ?? "unknown"}`,
+        `- Git worktree: ${pack.workspace.isWorktree ? "yes" : "no"}`
+      ].join("\n") + "\n"
+    );
+    if (pack.workspace.isWorktree) {
+      parts.push(
+        "You are inside a Git worktree. Work only in this workspace; run Kaddo commands from here.\n"
+      );
+    }
+  } else {
+    parts.push("- Not a Git repository\n");
+  }
   parts.push("## Current Phase\n");
   parts.push(`Phase: ${pack.phase.phase}
 `);
@@ -6252,6 +6333,12 @@ function runUnderstand() {
   if (assessment.nextStep) {
     console.log(`Next step: ${assessment.nextStep}`);
   }
+  if (exp.workspace.isWorktree) {
+    console.log("");
+    console.log(`Current implementation workspace: ${exp.workspace.branch ?? "(detached)"}`);
+    console.log("  \u2192 You are inside a Git worktree. Run scan, owners suggest, guard and explain");
+    console.log("    from this worktree so they reflect the code being changed here.");
+  }
   const active = activeWorkItems(dir);
   if (active.length > 0) {
     console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/cli",
-  "version": "3.11.2",
+  "version": "3.12.0",
   "description": "Knowledge Driven Development toolkit",
   "license": "MIT",
   "repository": {