@amistio/cli 0.1.15 → 0.1.17

package/README.md

@@ -39,6 +39,8 @@ Provider-backed model preferences use sanitized catalog fields: `--provider`, `-
 
 When `--tool copilot` uses the GitHub Copilot SDK, Amistio approves read-only permission requests by default and denies mutating, network, MCP, hook, memory, and shell requests. Set `AMISTIO_COPILOT_APPROVE_ALL=1` only on a local machine where broad Copilot SDK approval is intentional.
 
+When `--tool codex` uses the Codex SDK, intermediate progress can be quiet until the final response. For live Codex CLI logs, run `amistio run --watch --tool codex --invocation-channel command`.
+
 `amistio runner status` reports local background runner state, latest heartbeat, and bounded resource usage when available. Resource usage is latest-sample runner process memory/CPU plus safe aggregate system memory/load signals; it does not include source files, environment variables, command lines, process lists, credentials, or arbitrary local paths.
 
 The runner advertises its supported work kinds in heartbeats. Current runners can claim read-only `projectContextRefresh` jobs from the workspace Context panel and create due runner-driven refreshes when no fresh approved map exists. Context refreshes inspect the paired checkout locally without modifying files and submit only bounded summaries, slices, entities, relations, safe citations, confidence, freshness, and repo-relative paths. If a submitted context refresh contains unsafe evidence, unsafe paths, or a map too large to store safely, Amistio marks the refresh failed with a safe reason instead of storing the rejected raw result. Approved maps are reused as context packs for source-aware assistant and impact-preview work. Current runners can also claim read-only issue diagnosis jobs from the web Issues panel, generate root-cause analysis and a proposed fix, and submit that result without modifying source. They can claim manual read-only `appEvaluationScan` jobs from the workspace Evaluate panel and create at most one due hourly evaluation during normal watch/background polling when app evaluation is enabled for the repository link. Evaluation results contain bounded summaries, safe evidence, suggested actions, lifecycle proposals, and repo-relative paths only. Current runners can also claim manual read-only `securityPostureScan` jobs from the workspace Security panel and create due daily posture checks during normal watch/background polling. Security scan results contain bounded summaries, standard references, safe evidence, and repo-relative paths only; source, secrets, environment variables, command lines, process lists, credentials, provider sessions, and arbitrary local paths stay local. Implementation or cleanup is queued separately only after the user approves an issue analysis, app evaluation finding, or security remediation plan in the app.

package/dist/index.js

@@ -4,7 +4,7 @@
 import { createHash as createHash7, randomUUID } from "node:crypto";
 import { writeFile as writeFile9 } from "node:fs/promises";
 import os7 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 import { Command } from "commander";
 
 // ../shared/src/schemas.ts
@@ -773,6 +773,9 @@ var projectContextRepoPathSchema = z.string().trim().min(1).max(300).refine((val
   }
   return !value.split(/[\\/]+/).includes("..");
 }, "Path must be repository-relative without traversal");
+var projectContextCitationSchema = assistantCitationSchema.extend({
+  repoPath: projectContextRepoPathSchema.optional()
+});
 var projectContextCoverageSchema = z.object({
   status: projectContextFreshnessSchema.default("missing"),
   sliceCount: z.number().int().nonnegative().default(0),
@@ -789,7 +792,7 @@ var projectContextSliceSchema = z.object({
   repoPaths: z.array(projectContextRepoPathSchema).max(80).default([]),
   ownerHints: z.array(z.string().trim().min(1).max(160)).max(20).default([]),
   tags: z.array(z.string().trim().min(1).max(80)).max(30).default([]),
-  citations: z.array(assistantCitationSchema).default([]),
+  citations: z.array(projectContextCitationSchema).default([]),
   dependsOn: z.array(z.string().trim().min(1).max(160)).max(50).default([]),
   freshness: projectContextFreshnessSchema.default("fresh"),
   confidence: z.number().min(0).max(1).default(0.6),
@@ -803,7 +806,7 @@ var projectContextEntitySchema = z.object({
   summary: z.string().trim().min(1).max(1200).optional(),
   aliases: z.array(z.string().trim().min(1).max(200)).default([]),
   sliceIds: z.array(z.string().trim().min(1).max(160)).default([]),
-  citations: z.array(assistantCitationSchema).default([]),
+  citations: z.array(projectContextCitationSchema).default([]),
   confidence: z.number().min(0).max(1).default(0.6)
 });
 var projectContextRelationSchema = z.object({
@@ -812,7 +815,7 @@ var projectContextRelationSchema = z.object({
   fromId: z.string().trim().min(1).max(200),
   toId: z.string().trim().min(1).max(200),
   summary: z.string().trim().min(1).max(1200),
-  citations: z.array(assistantCitationSchema).default([]),
+  citations: z.array(projectContextCitationSchema).default([]),
   confidence: z.number().min(0).max(1).default(0.6)
 });
 var projectSystemDiagramStatusSchema = z.enum(["draft", "proposed", "approved", "stale", "archived"]);
@@ -829,7 +832,7 @@ var projectSystemDiagramNodeSchema = z.object({
   lane: z.string().trim().min(1).max(120).optional(),
   sliceIds: z.array(z.string().trim().min(1).max(160)).default([]),
   entityIds: z.array(z.string().trim().min(1).max(200)).default([]),
-  citations: z.array(assistantCitationSchema).min(1),
+  citations: z.array(projectContextCitationSchema).min(1),
   confidence: z.number().min(0).max(1).default(0.6),
   freshness: projectContextFreshnessSchema.default("fresh")
 });
@@ -840,7 +843,7 @@ var projectSystemDiagramEdgeSchema = z.object({
   relationType: knowledgeRelationTypeSchema.default("mentions"),
   label: z.string().trim().min(1).max(120).optional(),
   summary: z.string().trim().min(1).max(1200),
-  citations: z.array(assistantCitationSchema).min(1),
+  citations: z.array(projectContextCitationSchema).min(1),
   confidence: z.number().min(0).max(1).default(0.6),
   freshness: projectContextFreshnessSchema.default("fresh")
 });
@@ -849,7 +852,7 @@ var projectSystemDiagramGroupSchema = z.object({
   label: z.string().trim().min(1).max(120),
   kind: projectSystemDiagramGroupKindSchema.default("group"),
   summary: z.string().trim().min(1).max(1200).optional(),
-  citations: z.array(assistantCitationSchema).default([])
+  citations: z.array(projectContextCitationSchema).default([])
 });
 var projectSystemDiagramViewSchema = z.object({
   viewId: z.string().trim().min(1).max(160),
@@ -871,7 +874,7 @@ var projectSystemDiagramGraphManifestSchema = z.object({
   edges: z.array(projectSystemDiagramEdgeSchema).default([]),
   groups: z.array(projectSystemDiagramGroupSchema).default([]),
   views: z.array(projectSystemDiagramViewSchema).min(1),
-  citations: z.array(assistantCitationSchema).default([]),
+  citations: z.array(projectContextCitationSchema).default([]),
   unknowns: z.array(z.string().trim().min(1).max(300)).default([]),
   warnings: z.array(z.string().trim().min(1).max(600)).default([])
 });
@@ -957,7 +960,7 @@ var projectContextPackSchema = z.object({
   slices: z.array(projectContextSliceSchema).default([]),
   entities: z.array(projectContextEntitySchema).default([]),
   relations: z.array(projectContextRelationSchema).default([]),
-  citations: z.array(assistantCitationSchema).default([]),
+  citations: z.array(projectContextCitationSchema).default([]),
   freshnessWarnings: z.array(z.string().trim().min(1).max(600)).default([]),
   tokenEstimate: z.number().int().nonnegative().default(0),
   generatedAt: isoDateTimeSchema
@@ -2382,8 +2385,8 @@ var toolSessionMutationSchema = z3.object({
 });
 function resolveApiUrl(apiUrl, urlPath) {
   const base = apiUrl.endsWith("/") ? apiUrl.slice(0, -1) : apiUrl;
-  const path15 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
-  return new URL(`${base}${path15}`);
+  const path16 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
+  return new URL(`${base}${path16}`);
 }
 
 // src/orchestrator.ts
@@ -3195,6 +3198,9 @@ async function runCodexSdk(input) {
     approvalPolicy: "on-request",
     skipGitRepoCheck: true
   });
+  if (input.streamOutput) {
+    process.stderr.write("Codex SDK is running; intermediate progress may be quiet until the final response. Use --invocation-channel command for Codex CLI logs.\n");
+  }
   const result = await thread.run(input.prompt);
   if (input.streamOutput && result.finalResponse) {
     process.stdout.write(result.finalResponse);
@@ -4371,6 +4377,7 @@ function defaultSessionStorePath() {
 }
 
 // src/work-runner.ts
+import path10 from "node:path";
 var generationResultStart = "AMISTIO_BRAIN_GENERATION_RESULT_START";
 var generationResultEnd = "AMISTIO_BRAIN_GENERATION_RESULT_END";
 var assistantAnswerStart = "AMISTIO_ASSISTANT_ANSWER_START";
@@ -4385,6 +4392,7 @@ var appEvaluationStart = "AMISTIO_APP_EVALUATION_START";
 var appEvaluationEnd = "AMISTIO_APP_EVALUATION_END";
 var projectContextRefreshStart = "AMISTIO_PROJECT_CONTEXT_REFRESH_START";
 var projectContextRefreshEnd = "AMISTIO_PROJECT_CONTEXT_REFRESH_END";
+var validProjectContextSliceKinds = /* @__PURE__ */ new Set(["overview", "architecture", "domain", "data", "api", "frontend", "backend", "cli", "workflow", "operations", "security", "testing", "unknown"]);
 var validProjectContextEntityTypes = /* @__PURE__ */ new Set(["project", "system", "component", "domain", "tool", "decision", "feature", "risk", "team", "workflow", "unknown"]);
 var validProjectContextRelationTypes = /* @__PURE__ */ new Set(["uses", "depends_on", "decides", "supersedes", "touches", "blocks", "implements", "mentions"]);
 function createWorkExecutionPrompt(workItem, context) {
@@ -4489,10 +4497,12 @@ function createProjectContextRefreshPrompt(workItem, context) {
     "## Mapping Requirements",
     "",
     "- Create slices for architecture, domain, data, API, frontend, backend, CLI, workflows, operations, security, and testing when those surfaces exist.",
+    "- Use only these exact singular slice kind values: overview, architecture, domain, data, api, frontend, backend, cli, workflow, operations, security, testing, unknown.",
     "- Capture entities and relations that explain how the app is put together and where future work should look first.",
     "- Prefer summaries, repository-relative paths, short citations, tags, and freshness status over raw source excerpts.",
     "- Mark stale or missing areas explicitly instead of guessing.",
     "- Keep repoPaths repository-relative; never include /absolute paths or ../ traversal.",
+    "- If local inspection prints a path inside this checkout, convert it to the repository-relative path before returning JSON.",
     "",
     "## Data Safety",
     "",
@@ -4949,7 +4959,7 @@ function parseAppEvaluationScanResult(output) {
   const parsed = JSON.parse(stripJsonFence(payload));
   return appEvaluationScanResultSchema.parse(parsed);
 }
-function parseProjectContextRefreshResult(output) {
+function parseProjectContextRefreshResult(output, options = {}) {
   const start = output.indexOf(projectContextRefreshStart);
   const end = output.indexOf(projectContextRefreshEnd, start + projectContextRefreshStart.length);
   if (start === -1 || end === -1 || end <= start) {
@@ -4957,7 +4967,8 @@ function parseProjectContextRefreshResult(output) {
   }
   const payload = output.slice(start + projectContextRefreshStart.length, end).trim();
   const parsed = JSON.parse(stripJsonFence(payload));
-  return projectContextRefreshResultSchema.parse(normalizeProjectContextRefreshEnums(parsed));
+  const normalized = normalizeProjectContextRefreshPaths(normalizeProjectContextRefreshEnums(parsed), options);
+  return projectContextRefreshResultSchema.parse(normalized);
 }
 function projectContextRefreshSubmissionFailureSummary(result) {
   if (result.refresh.status !== "failed" && result.workItem.status !== "failed") {
@@ -5026,6 +5037,16 @@ function normalizeProjectContextRefreshEnums(value) {
     return value;
   }
   const normalized = { ...value };
+  if (Array.isArray(normalized.slices)) {
+    normalized.slices = normalized.slices.map((slice) => {
+      if (!isObjectRecord(slice)) {
+        return slice;
+      }
+      const normalizedSlice = { ...slice };
+      normalizedSlice.kind = normalizeProjectContextSliceKind(slice.kind);
+      return normalizedSlice;
+    });
+  }
   if (Array.isArray(normalized.entities)) {
     normalized.entities = normalized.entities.map((entity) => {
       if (!isObjectRecord(entity)) {
@@ -5048,6 +5069,94 @@ function normalizeProjectContextRefreshEnums(value) {
   }
   return normalized;
 }
+function normalizeProjectContextSliceKind(value) {
+  if (typeof value !== "string") {
+    return "unknown";
+  }
+  const normalized = value.trim().toLowerCase();
+  if (validProjectContextSliceKinds.has(normalized)) {
+    return normalized;
+  }
+  if (normalized.endsWith("s")) {
+    const singular = normalized.slice(0, -1);
+    if (validProjectContextSliceKinds.has(singular)) {
+      return singular;
+    }
+  }
+  return "unknown";
+}
+function normalizeProjectContextRefreshPaths(value, options) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const normalized = { ...value };
+  if (Array.isArray(normalized.slices)) {
+    normalized.slices = normalized.slices.map((slice) => normalizeProjectContextSlicePaths(slice, options));
+  }
+  if (Array.isArray(normalized.entities)) {
+    normalized.entities = normalized.entities.map((entity) => normalizeProjectContextCitationPaths(entity, options));
+  }
+  if (Array.isArray(normalized.relations)) {
+    normalized.relations = normalized.relations.map((relation) => normalizeProjectContextCitationPaths(relation, options));
+  }
+  return normalized;
+}
+function normalizeProjectContextSlicePaths(value, options) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const normalized = normalizeProjectContextCitationPaths(value, options);
+  if (Array.isArray(normalized.repoPaths)) {
+    normalized.repoPaths = normalized.repoPaths.map((repoPath) => typeof repoPath === "string" ? normalizeProjectContextRepoPath(repoPath, options) : repoPath);
+  }
+  return normalized;
+}
+function normalizeProjectContextCitationPaths(value, options) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const normalized = { ...value };
+  if (Array.isArray(normalized.citations)) {
+    normalized.citations = normalized.citations.map((citation) => {
+      if (!isObjectRecord(citation)) {
+        return citation;
+      }
+      const normalizedCitation = { ...citation };
+      if (typeof normalizedCitation.repoPath === "string") {
+        normalizedCitation.repoPath = normalizeProjectContextRepoPath(normalizedCitation.repoPath, options);
+      }
+      return normalizedCitation;
+    });
+  }
+  return normalized;
+}
+function normalizeProjectContextRepoPath(value, options) {
+  const trimmed = value.trim();
+  if (!trimmed || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed) || /^file:/i.test(trimmed) || /^[A-Za-z]:($|[^\\/])/.test(trimmed)) {
+    throwUnsafeProjectContextPath();
+  }
+  const absolute = trimmed.startsWith("/") || trimmed.startsWith("\\\\") || path10.isAbsolute(trimmed) || path10.win32.isAbsolute(trimmed);
+  if (!absolute) {
+    return normalizeRelativeProjectContextPath(trimmed);
+  }
+  if (!options.repositoryRoot) {
+    throwUnsafeProjectContextPath();
+  }
+  const useWindowsPathRules = path10.win32.isAbsolute(trimmed) && !trimmed.startsWith("/");
+  const relativePath = useWindowsPathRules ? path10.win32.relative(path10.win32.resolve(options.repositoryRoot), path10.win32.resolve(trimmed)) : path10.relative(path10.resolve(options.repositoryRoot), path10.resolve(trimmed));
+  return normalizeRelativeProjectContextPath(relativePath);
+}
+function normalizeRelativeProjectContextPath(value) {
+  const normalized = value.trim().replace(/\\/g, "/");
+  const segments = normalized.split("/").filter((segment) => segment.length > 0 && segment !== ".");
+  if (!segments.length || normalized.startsWith("/") || normalized === "~" || normalized.startsWith("~/") || /^[A-Za-z]:/.test(normalized) || segments.includes("..")) {
+    throwUnsafeProjectContextPath();
+  }
+  return segments.join("/");
+}
+function throwUnsafeProjectContextPath() {
+  throw new Error("Project context refresh contains an unsafe repository path.");
+}
 function normalizeProjectContextEntityType(value) {
   if (typeof value !== "string") {
     return "unknown";
@@ -5240,7 +5349,7 @@ function roundNumber(value, digits) {
 import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { readdir as readdir4, readFile as readFile8, stat as stat4 } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync4 = promisify4(execFile4);
 var defaultMaxFileKb = 256;
@@ -5259,12 +5368,12 @@ var documentFolderByType = {
   workflow: "docs/workflows"
 };
 async function inspectLocalRepository(rootDir, defaultBranch) {
-  const requestedRoot = path10.resolve(rootDir);
+  const requestedRoot = path11.resolve(rootDir);
   const root = await runGit2(["-C", requestedRoot, "rev-parse", "--show-toplevel"]).catch(() => requestedRoot);
   const detectedBranch = await runGit2(["-C", root, "symbolic-ref", "--quiet", "--short", "HEAD"]).catch(() => defaultBranch);
   const originUrl = await runGit2(["-C", root, "remote", "get-url", "origin"]).catch(() => void 0);
   const parsedCloneUrl = originUrl ? parseOptionalOriginCloneUrl(originUrl) : void 0;
-  const repoName = (parsedCloneUrl?.repoName ?? path10.basename(root)) || "repository";
+  const repoName = (parsedCloneUrl?.repoName ?? path11.basename(root)) || "repository";
   const fingerprintSeed = parsedCloneUrl ? `origin:${parsedCloneUrl.normalizedKey}` : `repo:${repoName}:${detectedBranch || defaultBranch}`;
   return {
     rootDir: root,
@@ -5276,7 +5385,7 @@ async function inspectLocalRepository(rootDir, defaultBranch) {
   };
 }
 async function scanLegacyDocuments(options) {
-  const rootDir = path10.resolve(options.rootDir);
+  const rootDir = path11.resolve(options.rootDir);
   const maxBytes = (options.maxFileKb ?? defaultMaxFileKb) * 1024;
   const skipped = [];
   const candidates = [];
@@ -5296,7 +5405,7 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "excluded" });
       continue;
     }
-    const fullPath = path10.join(rootDir, ...repoPath.split("/"));
+    const fullPath = path11.join(rootDir, ...repoPath.split("/"));
     const fileStat = await stat4(fullPath).catch(() => void 0);
     if (!fileStat?.isFile()) {
       skipped.push({ repoPath, reason: "unreadable" });
@@ -5398,8 +5507,8 @@ async function listRepositoryPaths(rootDir) {
 async function walkRepository(rootDir, directory, files) {
   const entries = await readdir4(directory, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path10.join(directory, entry.name);
-    const repoPath = normalizeRepoPath4(path10.relative(rootDir, fullPath));
+    const fullPath = path11.join(directory, entry.name);
+    const repoPath = normalizeRepoPath4(path11.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!excludedDirectoryNames.has(entry.name)) {
         await walkRepository(rootDir, fullPath, files);
@@ -5465,9 +5574,9 @@ function uniqueDestinationPath(basePath, sourcePath, usedPaths) {
     usedPaths.add(basePath);
     return basePath;
   }
-  const extension = path10.posix.extname(basePath) || ".md";
-  const directory = path10.posix.dirname(basePath);
-  const basename = path10.posix.basename(basePath, extension);
+  const extension = path11.posix.extname(basePath) || ".md";
+  const directory = path11.posix.dirname(basePath);
+  const basename = path11.posix.basename(basePath, extension);
   const uniquePath = `${directory}/${basename}-${hashText(sourcePath, 8)}${extension}`;
   usedPaths.add(uniquePath);
   return uniquePath;
@@ -5486,7 +5595,7 @@ function inferTitle2(content, repoPath) {
   if (heading) return heading;
   const htmlHeading = body.match(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i)?.[1]?.replace(/<[^>]+>/g, "").trim();
   if (htmlHeading) return htmlHeading;
-  const basename = path10.posix.basename(repoPath, path10.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
+  const basename = path11.posix.basename(repoPath, path11.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
   return titleCase(basename || "Imported Document");
 }
 function stripFrontmatter(content) {
@@ -5520,7 +5629,7 @@ async function runGit2(args) {
 
 // src/runner-actions.ts
 import { spawn as spawn4 } from "node:child_process";
-import path11 from "node:path";
+import path12 from "node:path";
 function buildBackgroundRunnerArgs(options) {
   const args = [
     "run",
@@ -5530,7 +5639,7 @@ function buildBackgroundRunnerArgs(options) {
     "--runner-id",
     options.runnerId,
     "--root",
-    path11.resolve(options.root),
+    path12.resolve(options.root),
     "--session",
     options.session,
     "--interval-seconds",
@@ -5648,7 +5757,7 @@ function truncateProcessOutput(value) {
 // src/git-worktree.ts
 import { execFile as execFile5 } from "node:child_process";
 import { mkdir as mkdir9, stat as stat5 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile5);
 function needsGitWorktreeIsolation(workItem) {
@@ -5677,7 +5786,7 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
     await assertExistingWorktree(worktreePath, identity.branch);
     return { ...identity, baseRevision, worktreePath };
   }
-  await mkdir9(path12.dirname(worktreePath), { recursive: true });
+  await mkdir9(path13.dirname(worktreePath), { recursive: true });
   const branchExists = await gitCommandSucceeds(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${identity.branch}`]);
   const worktreeArgs = branchExists ? ["worktree", "add", worktreePath, identity.branch] : ["worktree", "add", "-b", identity.branch, worktreePath, baseRevision];
   await gitOutput(repoRoot, worktreeArgs).catch((error) => {
@@ -5686,9 +5795,9 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
   return { ...identity, baseRevision, worktreePath };
 }
 function localWorktreePath(repoRoot, worktreeKey) {
-  const repoName = path12.basename(repoRoot);
+  const repoName = path13.basename(repoRoot);
   const worktreeSlug = worktreeKey.split("/").filter(Boolean).pop() ?? "work";
-  return path12.join(path12.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
+  return path13.join(path13.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
 }
 async function assertExistingWorktree(worktreePath, branch) {
   await gitOutput(worktreePath, ["rev-parse", "--is-inside-work-tree"]);
@@ -5735,7 +5844,7 @@ function errorMessage2(error) {
 
 // src/implementation-handoff.ts
 import { execFile as execFile6 } from "node:child_process";
-import path13 from "node:path";
+import path14 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync6 = promisify6(execFile6);
 async function completeImplementationHandoff(input) {
@@ -5821,7 +5930,7 @@ async function cleanupWorktree(run, input) {
     return { status: "failed", message: "Cleanup skipped because the worktree is not clean after PR handoff." };
   }
   try {
-    await gitOutput2(run, input.primaryRepoRoot || path13.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
+    await gitOutput2(run, input.primaryRepoRoot || path14.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
     return { status: "completed" };
   } catch (error) {
     return { status: "failed", message: `Cleanup failed: ${safeErrorMessage(error)}` };
@@ -6310,7 +6419,7 @@ program.command("run").description("Claim and run approved Amistio work locally"
       projectId: context.metadata.amistioProjectId,
       repositoryLinkId: context.metadata.repositoryLinkId,
       runnerId,
-      rootDir: path14.resolve(options.root),
+      rootDir: path15.resolve(options.root),
       apiUrl: options.apiUrl,
       args: buildBackgroundRunnerArgs(resolvedOptions)
     });
@@ -6482,7 +6591,7 @@ runnerService.command("install").description("Install a user-level startup servi
     projectId: context.metadata.amistioProjectId,
     repositoryLinkId: context.metadata.repositoryLinkId,
     runnerId,
-    rootDir: path14.resolve(options.root),
+    rootDir: path15.resolve(options.root),
     apiUrl: options.apiUrl,
     args,
     platform
@@ -6954,6 +7063,7 @@ async function runNextWorkItem({
       return await finalizeProjectContextRefreshWork({
         apiClient,
         durationMs: Date.now() - startedAt,
+        executionRoot,
         projectId,
         repositoryLinkId,
         runnerId,
@@ -7808,6 +7918,7 @@ ${toolResult.stderr}`);
 async function finalizeProjectContextRefreshWork({
   apiClient,
   durationMs,
+  executionRoot,
   projectId,
   repositoryLinkId,
   runnerId,
@@ -7822,7 +7933,7 @@ async function finalizeProjectContextRefreshWork({
   if (toolResult.exitCode === 0) {
     try {
       refreshResult = parseProjectContextRefreshResult(`${toolResult.stdout}
-${toolResult.stderr}`);
+${toolResult.stderr}`, { repositoryRoot: executionRoot });
     } catch (error) {
       refreshError = errorMessage3(error);
     }
@@ -8199,7 +8310,7 @@ function parseReasoningEffort(value) {
   throw new Error(`Expected reasoning effort auto, low, medium, high, or xhigh; received ${value}.`);
 }
 function inferRepoName(root) {
-  return path14.basename(path14.resolve(root)) || "repository";
+  return path15.basename(path15.resolve(root)) || "repository";
 }
 function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
   return createHash7("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");