@amistio/cli 0.1.58 → 0.1.60

package/README.md

@@ -107,6 +107,8 @@ Current runners recover abandoned server claims without impersonating the old ow
 
 Watch mode prints a completed-work success once per work item, keeps fresh completion visible briefly, and returns old completed work to the ready state when no queued, running, blocked, failed, review, or runner-readiness action needs attention. Unchanged idle-ready status is printed once and then stays quiet until the next action changes.
 
+If no work is claimed but a retryable project-status read fails, watch mode prints `Status unavailable` and retries on the next poll. This status is about the idle next-action summary, not the claimed work or finalization path.
+
 Known validation failures such as `unsafe_context_path` are printed with attention-needed next steps. For project-context refresh path-safety failures, deploy the latest web/API fix, update and restart the runner when applicable, retry the refresh, and capture only bounded non-secret output if it repeats.
 
 If watch mode reports that the runner was forgotten by the server, run `amistio runner repair` from the paired checkout, then start `amistio run --watch` again. The repair command stores a fresh local runner ID because the default ID for a machine/project/repository is stable and can remain tombstoned. Use `--clear-credential` only when the Runner panel tells you to create a fresh pairing code.

package/dist/index.js

@@ -5857,6 +5857,18 @@ function formatWatchStartupContext(input) {
 function formatWatchIdleLine(action, intervalSeconds) {
   return `${formatProjectNextAction(action)} Checking again in ${intervalSeconds}s.`;
 }
+function projectStatusUnavailableActionForError(error) {
+  if (!isRetryableApiError(error)) {
+    return void 0;
+  }
+  return {
+    kind: "idle",
+    actor: "system",
+    tone: "warning",
+    title: "Status unavailable",
+    message: "No work was claimed, but Amistio could not load the latest project status. The runner will retry on the next poll."
+  };
+}
 function shouldPrintWatchState(action, previous, nowMs, reminderMs = watchStateReminderMs) {
   const key = watchStateKey(action);
   if (!previous || previous.key !== key) {
@@ -7788,12 +7800,92 @@ var canonicalTestCommandKinds = /* @__PURE__ */ new Map([
 ]);
 var canonicalProjectContextCitationSources = /* @__PURE__ */ new Map([
   ["projectbrain", "projectBrain"],
+  ["brain", "projectBrain"],
+  ["docs", "projectBrain"],
+  ["document", "projectBrain"],
+  ["documents", "projectBrain"],
+  ["decision", "projectBrain"],
+  ["decisions", "projectBrain"],
+  ["plan", "projectBrain"],
+  ["plans", "projectBrain"],
+  ["prompt", "projectBrain"],
+  ["prompts", "projectBrain"],
+  ["feature", "projectBrain"],
+  ["features", "projectBrain"],
   ["approvedbrain", "projectBrain"],
   ["approvedprojectbrain", "projectBrain"],
+  ["approvedcontext", "projectBrain"],
   ["localsource", "localSource"],
+  ["source", "localSource"],
+  ["repository", "localSource"],
+  ["repo", "localSource"],
+  ["file", "localSource"],
+  ["files", "localSource"],
+  ["code", "localSource"],
+  ["workspace", "localSource"],
+  ["local", "localSource"],
   ["runnerstate", "runnerState"],
+  ["runner", "runnerState"],
+  ["workitem", "runnerState"],
+  ["work", "runnerState"],
+  ["claim", "runnerState"],
+  ["heartbeat", "runnerState"],
+  ["status", "runnerState"],
+  ["log", "runnerState"],
+  ["logs", "runnerState"],
+  ["execution", "runnerState"],
   ["mixed", "mixed"]
 ]);
+var canonicalImplementationVerificationEvidenceStatuses = /* @__PURE__ */ new Map([
+  ["satisfied", "satisfied"],
+  ["implemented", "satisfied"],
+  ["verified", "satisfied"],
+  ["complete", "satisfied"],
+  ["completed", "satisfied"],
+  ["passed", "satisfied"],
+  ["passing", "satisfied"],
+  ["present", "satisfied"],
+  ["done", "satisfied"],
+  ["met", "satisfied"],
+  ["fulfilled", "satisfied"],
+  ["success", "satisfied"],
+  ["successful", "satisfied"],
+  ["partial", "partial"],
+  ["partiallyimplemented", "partial"],
+  ["partlyimplemented", "partial"],
+  ["partiallymet", "partial"],
+  ["incomplete", "partial"],
+  ["mixed", "partial"],
+  ["warning", "partial"],
+  ["warnings", "partial"],
+  ["needswork", "partial"],
+  ["needsreview", "partial"],
+  ["repairneeded", "partial"],
+  ["followupneeded", "partial"],
+  ["missing", "missing"],
+  ["absent", "missing"],
+  ["failed", "missing"],
+  ["failing", "missing"],
+  ["failure", "missing"],
+  ["notimplemented", "missing"],
+  ["noimplementation", "missing"],
+  ["notpresent", "missing"],
+  ["unmet", "missing"],
+  ["gap", "missing"],
+  ["gaps", "missing"],
+  ["notfound", "missing"],
+  ["unknown", "unknown"],
+  ["uncertain", "unknown"],
+  ["inconclusive", "unknown"],
+  ["unverified", "unknown"],
+  ["notchecked", "unknown"],
+  ["unchecked", "unknown"],
+  ["unavailable", "unknown"],
+  ["skipped", "unknown"],
+  ["blocked", "unknown"],
+  ["blockedenvironment", "unknown"],
+  ["verificationblocked", "unknown"]
+]);
 var canonicalProjectContextFreshnessValues = /* @__PURE__ */ new Map([
   ["fresh", "fresh"],
   ["current", "fresh"],
@@ -7917,7 +8009,11 @@ function createImplementationVerificationPrompt(workItem) {
     "",
     "Print exactly one JSON object between the markers below. The CLI will submit only this structured verification result back to Amistio.",
     "Accepted outcome values: verifiedImplemented, partiallyImplemented, notImplemented, inconclusive, verificationBlocked.",
+    "Accepted evidence status values: satisfied, partial, missing, unknown.",
+    "Accepted check status values: passed, failed, blocked, skipped.",
+    "Accepted citation source values: projectBrain, localSource, runnerState, mixed.",
     "Accepted recommendation values: none, requeue, createFollowUpPlan, requestHumanReview, markBlocked.",
+    "Omit optional fields when unavailable; do not invent non-canonical enum values.",
     "",
     implementationVerificationStart,
     '{"outcome":"partiallyImplemented","summary":"The implementation is present in the workspace, but one acceptance check could not be confirmed.","evidence":[{"acceptanceCriterion":"The requested behavior is wired through the runner lifecycle.","status":"partial","summary":"The route and UI wiring exist, but the runner result submission still needs validation.","citations":[{"source":"localSource","repoPath":"src/apps/web/components/workspace-client.tsx","excerpt":"Implementation verification queued for the local runner."}]}],"checks":[{"name":"Focused typecheck","status":"passed","summary":"The touched package typechecked successfully.","safePaths":["src/apps/web"]}],"gaps":["Runner result submission was not exercised end to end."],"recommendation":"requestHumanReview","verificationPlan":["Run focused CLI tests","Review the verification evidence in Amistio"],"warnings":[]}',
@@ -8804,7 +8900,96 @@ function parseImplementationVerificationResult(output) {
   }
   const payload = output.slice(start + implementationVerificationStart.length, end).trim();
   const parsed = JSON.parse(stripJsonFence(payload));
-  return implementationVerificationResultSchema.parse(parsed);
+  return implementationVerificationResultSchema.parse(normalizeImplementationVerificationResult(parsed));
+}
+function normalizeImplementationVerificationResult(value) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  const normalized = { ...value };
+  if (Array.isArray(normalized.evidence)) {
+    normalized.evidence = normalized.evidence.map((evidence) => {
+      if (!isObjectRecord(evidence)) {
+        return evidence;
+      }
+      const normalizedEvidence = {
+        ...evidence,
+        status: normalizeImplementationVerificationEvidenceStatus(evidence.status)
+      };
+      if (Array.isArray(normalizedEvidence.citations)) {
+        normalizedEvidence.citations = normalizedEvidence.citations.map(normalizeImplementationVerificationCitation);
+      }
+      return normalizedEvidence;
+    });
+  }
+  return normalized;
+}
+function normalizeImplementationVerificationEvidenceStatus(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const key = normalizeEnumKey(value);
+  if (!key) {
+    return "unknown";
+  }
+  const direct = canonicalImplementationVerificationEvidenceStatuses.get(key);
+  if (direct) {
+    return direct;
+  }
+  for (const segment of value.split(/[\/,|]+/)) {
+    const segmentStatus = canonicalImplementationVerificationEvidenceStatuses.get(normalizeEnumKey(segment));
+    if (segmentStatus) {
+      return segmentStatus;
+    }
+  }
+  if (key.includes("notimplemented") || key.includes("noimplementation") || key.includes("notpresent") || key.includes("notfound") || key.includes("missing") || key.includes("absent") || key.includes("failed") || key.includes("failing") || key.includes("unmet")) {
+    return "missing";
+  }
+  if (key.includes("partial") || key.includes("incomplete") || key.includes("mixed") || key.includes("needs") || key.includes("followup") || key.includes("repair")) {
+    return "partial";
+  }
+  if (key.includes("implemented") || key.includes("verified") || key.includes("passed") || key.includes("passing") || key.includes("satisfied") || key.includes("complete") || key.includes("present")) {
+    return "satisfied";
+  }
+  return "unknown";
+}
+function normalizeImplementationVerificationCitation(value) {
+  if (!isObjectRecord(value)) {
+    return value;
+  }
+  return {
+    ...value,
+    source: normalizeImplementationVerificationCitationSource(value.source)
+  };
+}
+function normalizeImplementationVerificationCitationSource(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const key = normalizeEnumKey(value);
+  if (!key) {
+    return "mixed";
+  }
+  const direct = canonicalProjectContextCitationSources.get(key);
+  if (direct) {
+    return direct;
+  }
+  for (const segment of value.split(/[\/,|]+/)) {
+    const segmentSource = canonicalProjectContextCitationSources.get(normalizeEnumKey(segment));
+    if (segmentSource) {
+      return segmentSource;
+    }
+  }
+  if (key.includes("projectbrain") || key.includes("brain") || key.includes("approvedcontext") || key.includes("document") || key.includes("docs") || key.includes("decision") || key.includes("plan") || key.includes("prompt") || key.includes("feature")) {
+    return "projectBrain";
+  }
+  if (key.includes("localsource") || key.includes("source") || key.includes("repository") || key.includes("repo") || key.includes("file") || key.includes("code") || key.includes("workspace")) {
+    return "localSource";
+  }
+  if (key.includes("runnerstate") || key.includes("runner") || key.includes("workitem") || key.includes("claim") || key.includes("heartbeat") || key.includes("execution") || key.includes("log")) {
+    return "runnerState";
+  }
+  return "mixed";
 }
 function parseTestQualityScanResult(output) {
   const start = output.indexOf(testQualityStart);
@@ -14983,11 +15168,22 @@ function runnerIdentityScope(metadata) {
   };
 }
 async function loadProjectNextAction(apiClient, projectId, repositoryLinkId, root) {
-  const [{ workItems }, { documents }, { runners }] = await Promise.all([
-    apiClient.listWorkItems(projectId),
-    apiClient.listBrainDocuments(projectId),
-    apiClient.listRunners(projectId).catch(() => ({ runners: [] }))
-  ]);
+  let workItems;
+  let documents;
+  let runners;
+  try {
+    [{ workItems }, { documents }, { runners }] = await Promise.all([
+      apiClient.listWorkItems(projectId),
+      apiClient.listBrainDocuments(projectId),
+      apiClient.listRunners(projectId).catch(() => ({ runners: [] }))
+    ]);
+  } catch (error) {
+    const fallback = projectStatusUnavailableActionForError(error);
+    if (fallback) {
+      return fallback;
+    }
+    throw error;
+  }
   return computeProjectNextAction({
     projectId,
     repositoryLinks: [createCliRepositoryLink({ amistioAccountId: "local_runner", amistioProjectId: projectId, repositoryLinkId, defaultBranch: "main", lastSyncedRevision: 0 }, root)],

package/package.json

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