@amistio/cli 0.1.46 → 0.1.47

package/README.md

@@ -84,7 +84,7 @@ When `--tool codex` uses the Codex SDK, intermediate progress can be quiet until
 
 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. Current runners can claim manual read-only `testQualityScan` jobs from the workspace Test panel and create one due daily Test scan per repository when Test quality is enabled. Test scans run only existing lint, typecheck, test, coverage, build, or verify commands and submit bounded command summaries, coverage summaries, safe findings, blocked reasons, warnings, and repo-relative paths. Missing tests, missing coverage, low coverage, failing checks, flaky tests, and test gaps create reviewable plan-backed findings in the app. Current runners also claim `implementationTestGate` jobs before implementation completion, PR handoff, or runner-managed push; a passing gate is required unless the web Test panel records an audited override. Blocked implementation Test gates submit structured Test findings, such as `blockedEnvironment`, with safe evidence, a suggested action, and a verification plan. Current runners can claim read-only `implementationVerification` jobs from Tasks to prove whether completed implementation work actually landed; verification submits bounded acceptance-criteria evidence, checks, gaps, outcome, and recommendation without mutating source. 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, security remediation plan, or Test quality plan in the app.
 
-Approved implementation work uses Git as the handoff boundary. During worktree preflight, the runner locally copies eligible ignored root dotenv files such as `.env.local` or `.env.test.local` from the paired checkout into the implementation worktree when the target is missing and ignored, so local tests can use the same machine configuration. Dotenv values, variable names, file contents, and local paths are not uploaded to Amistio, and copied dotenv files stay ignored so PR handoff does not commit them. Before local AI/tool execution starts, implementation work checks PR handoff readiness: GitHub remote support, default-branch fetch, Git commit identity, local `gh` authentication, and repository visibility. After the local tool completes successfully, the runner materializes approved Markdown, MDX, and HTML project-brain artifacts for the same work scope into the isolated worktree before final Git status. It then commits all source and artifact changes, fetches and rebases from the linked remote's default branch, pushes an `amistio/work/...` branch, opens or reuses a pull request with the locally authenticated `gh` CLI, reports only safe PR and artifact-inclusion metadata to Amistio, and removes the local worktree after the PR URL is durable. Artifact-only materialization changes still create or reuse a PR; no-change completion requires no source changes and no approved artifact changes, and runner-created no-change worktrees are removed after final clean checks. Prepare the runner machine with Git commit identity, fetch/push permission to the linked remote, and `gh auth status`. If artifact materialization, commit, fetch/rebase, push, or PR creation fails, the work item is blocked with safe recovery choices; source files and patches are not uploaded to Amistio. The Work panel can queue scoped Retry handoff or Retry cleanup commands only to the runner that owns the preserved worktree for the same work item, branch, and worktree key. Retry handoff can publish a clean preserved local-only implementation commit without rerunning the implementation prompt. Rebase conflicts capture bounded repo-relative conflict files and try `git rebase --abort` so the implementation branch can be retried or manually reviewed without leaving an active rebase. Dirty, unmerged, or ambiguous worktrees are preserved rather than discarded.
+Approved implementation work uses Git as the handoff boundary. During worktree preflight, the runner locally copies eligible ignored root dotenv files such as `.env.local` or `.env.test.local` from the paired checkout into the implementation worktree when the target is missing and ignored, so local tests can use the same machine configuration. Dotenv values, variable names, file contents, and local paths are not uploaded to Amistio, and copied dotenv files stay ignored so PR handoff does not commit them. Before local AI/tool execution starts, implementation work checks PR handoff readiness: GitHub remote support, default-branch fetch, Git commit identity, local `gh` authentication, and repository visibility. After the local tool completes successfully, the runner materializes approved Markdown, MDX, and HTML project-brain artifacts for the same work scope into the isolated worktree before final Git status, then classifies the final diff. Source-implementation work must include source, config, test, or other implementation-affecting changes before the runner opens or reuses a PR. If only project-brain or documentation artifacts changed, Amistio reports no implementation produced and preserves recovery choices instead of opening a misleading implementation PR. Explicit docs-only work can still create docs-only PRs. No-change completion requires no source changes and no approved artifact changes, and runner-created no-change worktrees are removed after final clean checks. Prepare the runner machine with Git commit identity, fetch/push permission to the linked remote, and `gh auth status`. If artifact materialization, commit, fetch/rebase, push, or PR creation fails, the work item is blocked with safe recovery choices; source files and patches are not uploaded to Amistio. The Work panel can queue scoped Retry handoff or Retry cleanup commands only to the runner that owns the preserved worktree for the same work item, branch, and worktree key. Retry handoff can publish a clean preserved local-only implementation commit without rerunning the implementation prompt. Rebase conflicts capture bounded repo-relative conflict files and try `git rebase --abort` so the implementation branch can be retried or manually reviewed without leaving an active rebase. Dirty, unmerged, or ambiguous worktrees are preserved rather than discarded.
 
 Failed or stale work can be requeued from the web Tasks panel. Requeue creates a new linked work attempt and preserves the original terminal attempt for audit history; Requeue all sends one backend batch that recomputes safe candidates, reports already-active and skipped rows, and still uses linked attempts. Requeue is blocked while equivalent work is already active or when the paired runner does not advertise the needed work kind. Completed implementation status is separate from proof: queue `implementationVerification` from Tasks when a plan needs source-aware evidence before cleanup or implementation status decisions.
 

package/dist/index.js

@@ -154,7 +154,8 @@ var autopilotGuardCheckSchema = z.object({
   status: z.enum(["passed", "failed", "warning"]),
   summary: z.string().trim().min(1).max(600)
 });
-var implementationHandoffStatusSchema = z.enum(["notStarted", "noChanges", "prReady", "blocked", "failed"]);
+var implementationExpectedOutcomeSchema = z.enum(["sourceImplementation", "docsOnly", "analysisOnly", "verificationOnly"]);
+var implementationHandoffStatusSchema = z.enum(["notStarted", "noChanges", "prReady", "blocked", "failed", "noImplementationProduced"]);
 var implementationHandoffCleanupStatusSchema = z.enum(["notApplicable", "pending", "completed", "failed"]);
 var implementationHandoffRecoveryCategorySchema = z.enum(["noChangeCleaned", "rebaseConflict", "dirtyWorktree", "unresolvedConflicts", "providerBlocked", "cleanupRetryAvailable", "manualReview", "artifactBlocked", "nonGithubProvider"]);
 var implementationHandoffRecoveryActionSchema = z.enum(["retryHandoff", "requeueFreshAttempt", "keepForManualRepair", "cleanNoChangeWorktree", "markSupersededNoChanges", "exportHandoffDetails", "retryCleanup"]);
@@ -223,9 +224,19 @@ var implementationHandoffRecoverySchema = z.object({
 var implementationVerificationOutcomeSchema = z.enum(["verifiedImplemented", "partiallyImplemented", "notImplemented", "inconclusive", "verificationBlocked"]);
 var implementationVerificationStatusSchema = z.enum(["queued", "running", "completed", "failed", "blocked", "stale"]);
 var implementationProofStatusSchema = z.enum(["unverified", "verificationQueued", "verificationRunning", "verifiedImplemented", "partiallyImplemented", "notImplemented", "inconclusive", "verificationBlocked", "humanOverride"]);
+var implementationHandoffDiffClassificationSchema = z.enum(["noChanges", "sourceImplementation", "sourceAndArtifacts", "projectBrainOnly", "docsOnly"]);
+var implementationHandoffDiffSummarySchema = z.object({
+  classification: implementationHandoffDiffClassificationSchema,
+  sourceImplementationFileCount: z.number().int().nonnegative().default(0),
+  projectBrainArtifactFileCount: z.number().int().nonnegative().default(0),
+  documentationFileCount: z.number().int().nonnegative().default(0),
+  fileSamples: z.array(safeRepoPathSchema).max(25).default([])
+}).strict();
 var implementationHandoffSchema = z.object({
   provider: z.string().trim().min(1).max(80).optional(),
   status: implementationHandoffStatusSchema,
+  expectedOutcome: implementationExpectedOutcomeSchema.optional(),
+  diffSummary: implementationHandoffDiffSummarySchema.optional(),
   baseBranch: z.string().trim().min(1).max(200).optional(),
   headBranch: z.string().trim().min(1).max(200).optional(),
   remoteName: z.string().trim().min(1).max(80).optional(),
@@ -858,6 +869,7 @@ var workItemSchema = baseItemSchema.extend({
   implementationTestGateId: z.string().min(1).optional(),
   projectContextRefreshId: z.string().min(1).optional(),
   contextMissId: z.string().min(1).optional(),
+  changeId: z.string().min(1).optional(),
   sourceWorkItemId: z.string().min(1).optional(),
   requeueReason: z.string().trim().min(1).max(600).optional(),
   requeuedByUserId: z.string().min(1).optional(),
@@ -868,6 +880,7 @@ var workItemSchema = baseItemSchema.extend({
   implementationProofStatus: implementationProofStatusSchema.optional(),
   implementationVerificationOutcome: implementationVerificationOutcomeSchema.optional(),
   implementationVerificationResultId: z.string().min(1).optional(),
+  implementationExpectedOutcome: implementationExpectedOutcomeSchema.optional(),
   humanImplementationOverrideReason: z.string().trim().min(1).max(1e3).optional(),
   repositoryLinkId: z.string().min(1).optional(),
   reviewThreadId: z.string().min(1).optional(),
@@ -9696,6 +9709,7 @@ import { execFile as execFile6 } from "node:child_process";
 import path18 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync6 = promisify6(execFile6);
+var DEFAULT_IMPLEMENTATION_EXPECTED_OUTCOME = "sourceImplementation";
 async function checkImplementationHandoffReadiness(input) {
   const run = input.commandRunner ?? defaultCommandRunner;
   const headBranch = input.worktreeIsolation?.branch ?? input.workItem.executionBranch;
@@ -9776,6 +9790,7 @@ async function completeImplementationHandoff(input) {
   const run = input.commandRunner ?? defaultCommandRunner;
   const headBranch = input.worktreeIsolation?.branch ?? input.workItem.executionBranch;
   const baseBranch = input.baseBranch ?? input.repositoryLink?.defaultBranch ?? "main";
+  const expectedOutcome = input.workItem.implementationExpectedOutcome ?? DEFAULT_IMPLEMENTATION_EXPECTED_OUTCOME;
   if (!headBranch) {
     return blockedHandoff({ baseBranch, message: "Implementation handoff needs an execution branch before it can create a pull request." });
   }
@@ -9810,6 +9825,7 @@ async function completeImplementationHandoff(input) {
       });
     }
     const status = await gitOutput2(run, input.worktreePath, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+    const diffSummary = classifyHandoffDiff(status);
     if (!status) {
       if (input.includeCleanLocalCommits) {
         const cleanBranchHandoff = await completeCleanLocalCommitHandoff({ artifactResult, baseBranch, common, headBranch, input, run });
@@ -9821,6 +9837,8 @@ async function completeImplementationHandoff(input) {
       return {
         ...common,
         status: "noChanges",
+        expectedOutcome,
+        diffSummary,
         cleanupStatus: cleanup2.status,
         ...cleanup2.message ? { cleanupMessage: cleanup2.message } : {},
         artifacts: artifactResult,
@@ -9834,6 +9852,24 @@ async function completeImplementationHandoff(input) {
         message: cleanup2.status === "completed" ? "Local execution completed with no repository changes to hand off and the local worktree was cleaned up." : "Local execution completed with no repository changes to hand off."
       };
     }
+    if (expectedOutcome === "sourceImplementation" && diffSummary.sourceImplementationFileCount === 0) {
+      return {
+        ...common,
+        status: "noImplementationProduced",
+        expectedOutcome,
+        diffSummary,
+        cleanupStatus: "pending",
+        artifacts: artifactResult,
+        recovery: handoffRecovery(input, {
+          category: "manualReview",
+          availableActions: ["requeueFreshAttempt", "keepForManualRepair", "exportHandoffDetails"],
+          cleanupEligible: false,
+          rebaseAbortStatus: "notApplicable",
+          summary: "The runner finished, but the final diff contains only project-brain or documentation artifacts. Requeue implementation or explicitly approve this as docs-only before opening a PR."
+        }),
+        message: "Implementation expected source, config, or test changes, but only documentation or project-brain artifacts changed. No implementation PR was opened."
+      };
+    }
     const remoteName = await resolveRemoteName(run, input.worktreePath);
     const remoteUrl = await gitOutput2(run, input.worktreePath, ["remote", "get-url", remoteName]);
     const provider = input.repositoryLink?.provider ?? inferProvider(remoteUrl);
@@ -9842,6 +9878,8 @@ async function completeImplementationHandoff(input) {
         ...common,
         provider,
         remoteName,
+        expectedOutcome,
+        diffSummary,
         artifacts: artifactResult,
         message: "Automated pull request handoff currently requires a GitHub remote. Commit and push manually, or link a GitHub repository.",
         recovery: handoffRecovery(input, {
@@ -9869,6 +9907,8 @@ async function completeImplementationHandoff(input) {
     return {
       provider: "github",
       status: "prReady",
+      expectedOutcome,
+      diffSummary,
       baseBranch,
       headBranch,
       remoteName,
@@ -10174,6 +10214,70 @@ function blockedHandoff(input) {
     ...input
   };
 }
+function classifyHandoffDiff(status) {
+  const files = status ? safeRepoPathsFromStatus(status) : [];
+  let sourceImplementationFileCount = 0;
+  let projectBrainArtifactFileCount = 0;
+  let documentationFileCount = 0;
+  for (const file of files) {
+    if (isProjectBrainArtifactPath(file)) {
+      projectBrainArtifactFileCount += 1;
+    } else if (isDocumentationPath(file)) {
+      documentationFileCount += 1;
+    } else {
+      sourceImplementationFileCount += 1;
+    }
+  }
+  const classification = sourceImplementationFileCount > 0 ? projectBrainArtifactFileCount > 0 || documentationFileCount > 0 ? "sourceAndArtifacts" : "sourceImplementation" : projectBrainArtifactFileCount > 0 ? documentationFileCount > 0 ? "docsOnly" : "projectBrainOnly" : documentationFileCount > 0 ? "docsOnly" : "noChanges";
+  return {
+    classification,
+    sourceImplementationFileCount,
+    projectBrainArtifactFileCount,
+    documentationFileCount,
+    fileSamples: files.slice(0, 25)
+  };
+}
+function safeRepoPathsFromStatus(status) {
+  const paths = [];
+  const parts = status.split("\0").filter(Boolean);
+  for (let index = 0; index < parts.length; index += 1) {
+    const entry = parts[index];
+    const statusCode = entry.slice(0, 2);
+    const parsedPath = entry.slice(entry[2] === " " ? 3 : 0).trim();
+    if (statusCode.includes("R") || statusCode.includes("C")) {
+      const nextPath = parts[index + 1];
+      if (nextPath && !/^[ MADRCU?!]{2} /.test(nextPath)) {
+        index += 1;
+        addSafePath(paths, nextPath.trim());
+        continue;
+      }
+    }
+    addSafePath(paths, parsedPath);
+  }
+  return [...new Set(paths)].slice(0, 100);
+}
+function addSafePath(paths, repoPath) {
+  if (!repoPath || repoPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(repoPath) || repoPath.split(/[\\/]+/).includes("..")) {
+    return;
+  }
+  paths.push(repoPath);
+}
+function isProjectBrainArtifactPath(repoPath) {
+  return [
+    "docs/architecture/",
+    "docs/context/",
+    "docs/decisions/",
+    "docs/features/",
+    "docs/memory/",
+    "docs/plans/",
+    "docs/prompts/",
+    "docs/workflows/"
+  ].some((prefix) => repoPath.startsWith(prefix));
+}
+function isDocumentationPath(repoPath) {
+  const basename = repoPath.split("/").pop() ?? repoPath;
+  return /\.(?:md|mdx|html)$/i.test(basename);
+}
 function inferProvider(remoteUrl) {
   try {
     return parseRepositoryCloneUrl(remoteUrl).provider ?? "other";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amistio/cli",
-  "version": "0.1.46",
+  "version": "0.1.47",
   "type": "module",
   "repository": {
     "type": "git",