@kody-ade/kody-engine 0.4.321 → 0.4.322

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.321",
+      version: "0.4.322",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -3942,6 +3942,73 @@ var init_capabilityReport = __esm({
   }
 });
 
+// src/goal/evidenceState.ts
+function parseGoalEvidenceState(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out = {};
+  for (const [evidence, value] of Object.entries(raw)) {
+    const progress = parseGoalEvidenceProgress(value);
+    if (progress) out[evidence] = progress;
+  }
+  return out;
+}
+function mergeGoalEvidenceProgress(state, evidence, update) {
+  const prior = state[evidence];
+  const next = {
+    resultClass: update.resultClass,
+    attempts: update.attempts ?? prior?.attempts ?? 0,
+    ...prior?.reason ? { reason: prior.reason } : {},
+    ...prior?.nextAction ? { nextAction: prior.nextAction } : {},
+    ...prior?.nextRetryAt ? { nextRetryAt: prior.nextRetryAt } : {},
+    ...prior?.issue ? { issue: prior.issue } : {},
+    ...prior?.updatedAt ? { updatedAt: prior.updatedAt } : {},
+    ...definedProgressFields(update)
+  };
+  return {
+    ...state,
+    [evidence]: next
+  };
+}
+function isGoalEvidenceResultClass(value) {
+  return value === "succeeded" || value === "pending" || value === "retryable" || value === "needsFix" || value === "fatal";
+}
+function parseGoalEvidenceProgress(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (!isGoalEvidenceResultClass(raw.resultClass)) return null;
+  const attempts = typeof raw.attempts === "number" && raw.attempts >= 0 ? Math.floor(raw.attempts) : 0;
+  return {
+    resultClass: raw.resultClass,
+    attempts,
+    ...stringField2(raw.reason) ? { reason: stringField2(raw.reason) } : {},
+    ...stringField2(raw.nextAction) ? { nextAction: stringField2(raw.nextAction) } : {},
+    ...stringField2(raw.nextRetryAt) ? { nextRetryAt: stringField2(raw.nextRetryAt) } : {},
+    ...positiveInteger(raw.issue) ? { issue: positiveInteger(raw.issue) } : {},
+    ...stringField2(raw.updatedAt) ? { updatedAt: stringField2(raw.updatedAt) } : {}
+  };
+}
+function definedProgressFields(update) {
+  const out = {};
+  if (update.reason !== void 0) out.reason = update.reason;
+  if (update.nextAction !== void 0) out.nextAction = update.nextAction;
+  if (update.nextRetryAt !== void 0) out.nextRetryAt = update.nextRetryAt;
+  if (update.issue !== void 0) out.issue = update.issue;
+  if (update.updatedAt !== void 0) out.updatedAt = update.updatedAt;
+  return out;
+}
+function stringField2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function positiveInteger(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+  return void 0;
+}
+var init_evidenceState = __esm({
+  "src/goal/evidenceState.ts"() {
+    "use strict";
+  }
+});
+
 // src/capabilityResult.ts
 function parseCapabilityResultsFromText(text) {
   const results = [];
@@ -3979,6 +4046,7 @@ function parseCapabilityResult(raw) {
     version: 1,
     ...target ? { target } : {},
     status: obj.status,
+    ...isGoalEvidenceResultClass(obj.resultClass) ? { resultClass: obj.resultClass } : {},
     summary,
     ...evidence ? { evidence } : {},
     facts,
@@ -4038,6 +4106,7 @@ var init_capabilityResult = __esm({
   "src/capabilityResult.ts"() {
     "use strict";
     init_capabilityReport();
+    init_evidenceState();
     RESULT_LINE = /^KODY_(?:CAPABILITY|CAPABILITY)_RESULT=(.+)$/gm;
     STATUSES = /* @__PURE__ */ new Set(["pass", "fail", "blocked", "changed", "noop"]);
     CONTROL_FACT_KEYS2 = /* @__PURE__ */ new Set(["blockers", "destination", "capabilities", "route", "stage", "state"]);
@@ -6831,6 +6900,8 @@ function planManagedGoalTick(goal) {
   if (!missing) {
     goal.stage = "done";
     delete goal.facts.pendingEvidence;
+    goal.reason = "destination evidence satisfied";
+    goal.nextAction = "done";
     return { kind: "done" };
   }
   const step = goal.route.find((candidate) => candidate.evidence === missing);
@@ -6840,32 +6911,44 @@ function planManagedGoalTick(goal) {
       delete goal.facts.pendingEvidence;
       const total = typeof goal.facts.simpleAttachedTaskCount === "number" ? goal.facts.simpleAttachedTaskCount : 0;
       const open = typeof goal.facts.simpleOpenTaskCount === "number" ? goal.facts.simpleOpenTaskCount : 0;
+      goal.reason = total === 0 ? "waiting for labelled tasks" : `waiting for ${open} open labelled task(s)`;
+      goal.nextAction = "wait";
       return {
         kind: "wait",
         evidence: missing,
         stage: "waiting",
-        reason: total === 0 ? "waiting for labelled tasks" : `waiting for ${open} open labelled task(s)`
+        reason: goal.reason
       };
     }
     const reason = `no route step for evidence: ${missing}`;
     goal.stage = "blocked";
+    goal.reason = reason;
+    goal.nextAction = "fix route";
     pushBlocker(goal, reason);
     return { kind: "blocked", evidence: missing, stage: "blocked", reason };
   }
+  const progressDecision = decisionFromEvidenceProgress(goal, step, missing);
+  if (progressDecision) return progressDecision;
   if (!goal.capabilities.includes(step.capability)) {
     const reason = `route capability ${step.capability} is not attached to this goal`;
     goal.stage = "blocked";
+    goal.reason = reason;
+    goal.nextAction = "attach capability";
     pushBlocker(goal, reason);
     return { kind: "blocked", evidence: missing, stage: step.stage, reason };
   }
   const resolved = resolveRouteArgs(goal, step);
   if (!resolved.ok) {
     goal.stage = "blocked";
+    goal.reason = resolved.reason;
+    goal.nextAction = "fix route args";
     pushBlocker(goal, resolved.reason);
     return { kind: "blocked", evidence: missing, stage: step.stage, reason: resolved.reason };
   }
   goal.stage = step.stage;
   goal.facts.pendingEvidence = missing;
+  goal.reason = `dispatch ${step.capability} for ${missing}`;
+  goal.nextAction = "dispatch";
   return {
     kind: "dispatch",
     evidence: missing,
@@ -6876,6 +6959,79 @@ function planManagedGoalTick(goal) {
     ...step.saveReport === true ? { saveReport: true } : {}
   };
 }
+function decisionFromEvidenceProgress(goal, step, evidence) {
+  const progress = goal.evidenceState?.[evidence];
+  if (!progress) return null;
+  if (progress.resultClass === "pending") {
+    const policy = step.onPending ?? { action: "wait" };
+    if (policy.action === "retry") return null;
+    if (policy.action === "block" || policy.action === "issue") {
+      const reason2 = progress.reason ?? `waiting for ${evidence}`;
+      goal.stage = "blocked";
+      goal.reason = reason2;
+      goal.nextAction = policy.action === "issue" ? "create issue" : "block";
+      pushBlocker(goal, reason2);
+      return { kind: "blocked", evidence, stage: step.stage, reason: reason2 };
+    }
+    const reason = progress.reason ?? `waiting for ${evidence}`;
+    goal.stage = step.stage;
+    goal.reason = reason;
+    goal.nextAction = progress.nextAction ?? "wait";
+    return { kind: "wait", evidence, stage: step.stage, reason };
+  }
+  if (progress.resultClass === "retryable") {
+    const policy = step.onFailure ?? { action: "retry" };
+    if (policy.action === "block" || policy.action === "issue") {
+      const reason = progress.reason ?? `retryable failure for ${evidence}`;
+      goal.stage = "blocked";
+      goal.reason = reason;
+      goal.nextAction = policy.action === "issue" ? "create issue" : "block";
+      pushBlocker(goal, reason);
+      return { kind: "blocked", evidence, stage: step.stage, reason };
+    }
+    if (policy.action === "wait") {
+      const reason = progress.reason ?? `waiting to retry ${evidence}`;
+      goal.stage = step.stage;
+      goal.reason = reason;
+      goal.nextAction = progress.nextRetryAt ? `retry after ${progress.nextRetryAt}` : "wait";
+      return { kind: "wait", evidence, stage: step.stage, reason };
+    }
+    if (policy.maxAttempts !== void 0 && progress.attempts >= policy.maxAttempts) {
+      const reason = `retry limit reached for ${evidence}`;
+      goal.stage = "blocked";
+      goal.reason = reason;
+      goal.nextAction = "create issue";
+      pushBlocker(goal, reason);
+      return { kind: "blocked", evidence, stage: step.stage, reason };
+    }
+    if (progress.nextRetryAt && Date.parse(progress.nextRetryAt) > Date.now()) {
+      const reason = progress.reason ?? `retry ${evidence} after ${progress.nextRetryAt}`;
+      goal.stage = step.stage;
+      goal.reason = reason;
+      goal.nextAction = `retry after ${progress.nextRetryAt}`;
+      return { kind: "wait", evidence, stage: step.stage, reason };
+    }
+    return null;
+  }
+  if (progress.resultClass === "needsFix" || progress.resultClass === "fatal") {
+    const policy = step.onFailure ?? defaultFailurePolicy(progress.resultClass);
+    if (policy.action === "retry") return null;
+    const reason = progress.reason ?? `${resultClassLabel(progress.resultClass)} for ${evidence}`;
+    goal.stage = "blocked";
+    goal.reason = reason;
+    goal.nextAction = progress.issue ? `fix issue #${progress.issue}` : policy.action === "issue" ? "create issue" : "block";
+    pushBlocker(goal, reason);
+    return { kind: "blocked", evidence, stage: step.stage, reason };
+  }
+  return null;
+}
+function defaultFailurePolicy(resultClass) {
+  return resultClass === "needsFix" ? { action: "issue" } : { action: "block" };
+}
+function resultClassLabel(resultClass) {
+  if (resultClass === "needsFix") return "needs fix";
+  return resultClass;
+}
 function asStringArray(value) {
   if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) return null;
   return [...value];
@@ -6901,11 +7057,30 @@ function asRoute(value) {
       capability: raw.capability,
       executable: typeof raw.executable === "string" ? raw.executable : void 0,
       args: args ?? void 0,
-      saveReport: raw.saveReport === true
+      saveReport: raw.saveReport === true,
+      onPending: asRoutePolicy(raw.onPending),
+      onFailure: asRoutePolicy(raw.onFailure)
     });
   }
   return route;
 }
+function asRoutePolicy(value) {
+  if (typeof value === "string") {
+    return isRoutePolicyAction(value) ? { action: value } : void 0;
+  }
+  const raw = asRecord(value);
+  if (!raw || !isRoutePolicyAction(raw.action)) return void 0;
+  const maxAttempts = typeof raw.maxAttempts === "number" && Number.isInteger(raw.maxAttempts) && raw.maxAttempts > 0 ? raw.maxAttempts : void 0;
+  const retryAfterSeconds = typeof raw.retryAfterSeconds === "number" && raw.retryAfterSeconds >= 0 ? Math.floor(raw.retryAfterSeconds) : void 0;
+  return {
+    action: raw.action,
+    ...maxAttempts !== void 0 ? { maxAttempts } : {},
+    ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {}
+  };
+}
+function isRoutePolicyAction(value) {
+  return value === "wait" || value === "retry" || value === "block" || value === "issue";
+}
 function asPreferredRunTime(value) {
   const raw = asRecord(value);
   if (!raw) return void 0;
@@ -6941,7 +7116,10 @@ function managedGoalFromState(state) {
     loopTarget: asLoopTarget(extra.loopTarget),
     stage: typeof extra.stage === "string" ? extra.stage : void 0,
     facts,
-    blockers
+    blockers,
+    evidenceState: parseGoalEvidenceState(extra.evidenceState),
+    reason: typeof extra.reason === "string" ? extra.reason : void 0,
+    nextAction: typeof extra.nextAction === "string" ? extra.nextAction : void 0
   };
 }
 function writeManagedGoalToState(state, goal) {
@@ -6955,7 +7133,10 @@ function writeManagedGoalToState(state, goal) {
       route: goal.route,
       stage: goal.stage,
       facts: goal.facts,
-      blockers: goal.blockers
+      blockers: goal.blockers,
+      evidenceState: goal.evidenceState ?? {},
+      reason: goal.reason,
+      nextAction: goal.nextAction
     }
   };
 }
@@ -6963,6 +7144,7 @@ var SIMPLE_GOAL_TYPE, SIMPLE_GOAL_EVIDENCE;
 var init_manager = __esm({
   "src/goal/manager.ts"() {
     "use strict";
+    init_evidenceState();
     SIMPLE_GOAL_TYPE = "simple";
     SIMPLE_GOAL_EVIDENCE = "labelledTasksComplete";
   }
@@ -7072,7 +7254,8 @@ function goalRunLogSnapshot(goalId, goalState, goal) {
     preferredRunTime: goal.preferredRunTime,
     loopTarget: goal.loopTarget,
     blockers: [...goal.blockers],
-    facts: { ...goal.facts }
+    facts: { ...goal.facts },
+    evidenceState: { ...goal.evidenceState ?? {} }
   };
 }
 function goalRunLogChange(before, after) {
@@ -7096,6 +7279,11 @@ function goalRunLogChange(before, after) {
     const evidence = diffStringArrays(beforeSatisfied ?? [], afterSatisfied ?? []);
     if (evidence.added.length > 0 || evidence.removed.length > 0) change.satisfiedEvidence = evidence;
   }
+  const beforeEvidenceState = recordValue2(before.evidenceState);
+  const afterEvidenceState = recordValue2(after.evidenceState);
+  if (beforeEvidenceState || afterEvidenceState) {
+    change.evidenceState = diffRecordKeys(beforeEvidenceState ?? {}, afterEvidenceState ?? {});
+  }
   return Object.keys(change).length > 0 ? change : void 0;
 }
 function goalRunLogs(data) {
@@ -7456,11 +7644,11 @@ function parseTodoGoalState(goalId, filePath, raw) {
   const data = parseJsonRecord(raw) ?? {};
   const items = normalizeItems(data.items);
   const destination = recordField(data.destination);
-  const evidence = stringArray(destination.evidence).length > 0 ? stringArray(destination.evidence) : stringArray(data.evidence).length > 0 ? stringArray(data.evidence) : items.map((item) => stringField2(recordField(item.meta).evidence) || item.id).filter(Boolean);
+  const evidence = stringArray(destination.evidence).length > 0 ? stringArray(destination.evidence) : stringArray(data.evidence).length > 0 ? stringArray(data.evidence) : items.map((item) => stringField3(recordField(item.meta).evidence) || item.id).filter(Boolean);
   const facts = {
     ...recordField(data.facts),
     ...Object.fromEntries(
-      items.map((item) => [stringField2(recordField(item.meta).evidence) || item.id, item.completed])
+      items.map((item) => [stringField3(recordField(item.meta).evidence) || item.id, item.completed])
     )
   };
   const route = Array.isArray(data.route) ? data.route : routeFromItems(items);
@@ -7472,10 +7660,10 @@ function parseTodoGoalState(goalId, filePath, raw) {
     type: data.type ?? "general",
     destination: {
       ...destination,
-      outcome: stringField2(data.description) || stringField2(destination.outcome),
+      outcome: stringField3(data.description) || stringField3(destination.outcome),
       evidence
     },
-    capabilities: stringArray(data.capabilities).length > 0 ? stringArray(data.capabilities) : route.map((step) => stringField2(step.capability)).filter(Boolean),
+    capabilities: stringArray(data.capabilities).length > 0 ? stringArray(data.capabilities) : route.map((step) => stringField3(step.capability)).filter(Boolean),
     route,
     facts,
     blockers: stringArray(data.blockers)
@@ -7487,16 +7675,25 @@ function isManagedTodoRaw(raw) {
 function serializeTodoGoalState(goalId, state, previousRaw) {
   const raw = JSON.parse(serializeGoalState(state));
   const destination = recordField(raw.destination);
-  const outcome = stringField2(raw.description) || stringField2(destination.outcome);
+  const outcome = stringField3(raw.description) || stringField3(destination.outcome);
   const evidence = stringArray(destination.evidence).length > 0 ? stringArray(destination.evidence) : stringArray(raw.evidence);
   const route = Array.isArray(raw.route) ? raw.route : [];
   const facts = recordField(raw.facts);
+  const evidenceState = recordField(raw.evidenceState);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const createdAt = stringField2(raw.createdAt) || stringField2(raw.startedAt) || now;
-  const routeByEvidence = new Map(route.map((step) => [stringField2(step.evidence), step]));
+  const createdAt = stringField3(raw.createdAt) || stringField3(raw.startedAt) || now;
+  const routeByEvidence = new Map(route.map((step) => [stringField3(step.evidence), step]));
   const previousItems = new Map(parseItemsFromAnyRaw(previousRaw ?? "").map((item) => [item.id, item]));
   const items = evidence.length > 0 ? evidence.map(
-    (key) => itemFromEvidence(key, routeByEvidence.get(key), facts, createdAt, now, previousItems.get(key))
+    (key) => itemFromEvidence(
+      key,
+      routeByEvidence.get(key),
+      facts,
+      evidenceState,
+      createdAt,
+      now,
+      previousItems.get(key)
+    )
   ) : stringArray(raw.capabilities).map(
     (capability) => itemFromCapability(capability, createdAt, previousItems.get(capability))
   );
@@ -7521,11 +7718,12 @@ function serializeTodoGoalState(goalId, state, previousRaw) {
 function isManagedTodoRecord(record2) {
   return record2.managed === true || record2.managed === "true" || record2.managedModel === "agentGoal" || record2.managedModel === "agentLoop";
 }
-function itemFromEvidence(evidence, step, facts, createdAt, now, prior) {
+function itemFromEvidence(evidence, step, facts, evidenceState, createdAt, now, prior) {
   const completed = facts[evidence] === true;
+  const progress = recordField(evidenceState[evidence]);
   return {
     id: evidence,
-    title: (prior?.title ?? stringField2(step?.stage)) || evidence,
+    title: (prior?.title ?? stringField3(step?.stage)) || evidence,
     body: prior?.body ?? "",
     assignee: prior?.assignee ?? null,
     completed,
@@ -7534,11 +7732,19 @@ function itemFromEvidence(evidence, step, facts, createdAt, now, prior) {
     meta: {
       ...prior?.meta ?? {},
       evidence,
+      ...stringField3(progress?.resultClass) ? { resultClass: stringField3(progress?.resultClass) } : {},
+      ...typeof progress?.attempts === "number" ? { attempts: progress.attempts } : {},
+      ...stringField3(progress?.reason) ? { reason: stringField3(progress?.reason) } : {},
+      ...stringField3(progress?.nextAction) ? { nextAction: stringField3(progress?.nextAction) } : {},
+      ...stringField3(progress?.nextRetryAt) ? { nextRetryAt: stringField3(progress?.nextRetryAt) } : {},
+      ...typeof progress?.issue === "number" ? { issue: progress.issue } : {},
       ...step ? {
-        stage: stringField2(step.stage),
-        capability: stringField2(step.capability),
+        stage: stringField3(step.stage),
+        capability: stringField3(step.capability),
         ...step.args && typeof step.args === "object" ? { args: step.args } : {},
-        ...step.saveReport === true ? { saveReport: true } : {}
+        ...step.saveReport === true ? { saveReport: true } : {},
+        ...step.onPending && typeof step.onPending === "object" ? { onPending: step.onPending } : {},
+        ...step.onFailure && typeof step.onFailure === "object" ? { onFailure: step.onFailure } : {}
       } : {}
     }
   };
@@ -7558,9 +7764,9 @@ function itemFromCapability(capability, createdAt, prior) {
 function routeFromItems(items) {
   return items.flatMap((item) => {
     const meta = recordField(item.meta);
-    const evidence = stringField2(meta.evidence) || item.id;
-    const stage = stringField2(meta.stage);
-    const capability = stringField2(meta.capability);
+    const evidence = stringField3(meta.evidence) || item.id;
+    const stage = stringField3(meta.stage);
+    const capability = stringField3(meta.capability);
     if (!evidence || !stage || !capability) return [];
     return [
       {
@@ -7568,7 +7774,9 @@ function routeFromItems(items) {
         stage,
         capability,
         ...meta.args ? { args: meta.args } : {},
-        ...meta.saveReport === true ? { saveReport: true } : {}
+        ...meta.saveReport === true ? { saveReport: true } : {},
+        ...meta.onPending ? { onPending: meta.onPending } : {},
+        ...meta.onFailure ? { onFailure: meta.onFailure } : {}
       }
     ];
   });
@@ -7591,7 +7799,7 @@ function parseJsonRecord(raw) {
 function recordField(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringField2(value) {
+function stringField3(value) {
   return typeof value === "string" ? value : "";
 }
 function stringArray(value) {
@@ -8431,7 +8639,9 @@ async function planGoalCapabilitySchedule(opts) {
   const backend = resolveBackend({ config: opts.config, cwd: opts.cwd, jobsDir });
   const statuses = {};
   const blockers = [];
-  for (const slug2 of opts.goal.capabilities) {
+  const explicitCapabilityTarget = opts.goal.loopTarget?.type === "capability" ? opts.goal.loopTarget.id.trim() : "";
+  const capabilitySlugs = explicitCapabilityTarget ? [explicitCapabilityTarget] : opts.goal.capabilities;
+  for (const slug2 of capabilitySlugs) {
     const capability2 = resolveCapabilityFolder(slug2, jobsRoot);
     const status = await describeCapabilitySchedule(
       capability2,
@@ -8442,7 +8652,7 @@ async function planGoalCapabilitySchedule(opts) {
     statuses[slug2] = status;
     if (status.state === "blocked") blockers.push(`${slug2}: ${status.reason}`);
   }
-  const due = opts.goal.capabilities.map((slug2) => statuses[slug2]).filter((status) => status?.state === "due").sort(compareOldestLastFired)[0];
+  const due = capabilitySlugs.map((slug2) => statuses[slug2]).filter((status) => status?.state === "due").sort(compareOldestLastFired)[0];
   if (!due) {
     const reason = blockers.length > 0 ? "no runnable capability; blocked capabilities need attention" : "no runnable capability";
     const kind = blockers.length > 0 ? "blocked" : "idle";
@@ -9241,16 +9451,16 @@ function normalizeCompanyIntent(path51, raw) {
     throw new Error(`${path51}: intent must be JSON object`);
   }
   const input = raw;
-  const id = stringField3(input.id);
+  const id = stringField4(input.id);
   if (!id || !isCompanyIntentId(id)) throw new Error(`${path51}: invalid intent id`);
-  const createdAt = stringField3(input.createdAt) || nowIso();
-  const updatedAt = stringField3(input.updatedAt) || createdAt;
-  const description = stringField3(input.description);
+  const createdAt = stringField4(input.createdAt) || nowIso();
+  const updatedAt = stringField4(input.updatedAt) || createdAt;
+  const description = stringField4(input.description);
   return {
     version: 1,
     id,
     status: oneOf2(input.status, ["active", "paused", "archived"], "active"),
-    for: stringField3(input.for),
+    for: stringField4(input.for),
     ...description ? { description } : {},
     priority: numberField(input.priority, 100),
     posture: oneOf2(
@@ -9324,8 +9534,8 @@ function listCompanyPortfolio(config, cwd) {
     goals.push({
       id,
       state: state.state,
-      type: stringField3(state.extra.type) || void 0,
-      outcome: stringField3(destination?.outcome) || void 0,
+      type: stringField4(state.extra.type) || void 0,
+      outcome: stringField4(destination?.outcome) || void 0,
       capabilities: stringArray4(state.extra.capabilities),
       isLoop: state.extra.scheduleMode === "agentLoop" || state.extra.type === "agentLoop",
       updatedAt: state.updatedAt
@@ -9340,7 +9550,7 @@ function writeCompanyGoalState(config, cwd, id, state, message) {
 function assertIntentId(id) {
   if (!isCompanyIntentId(id)) throw new Error(`invalid intent/portfolio id: ${id}`);
 }
-function stringField3(value) {
+function stringField4(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function numberField(value, fallback) {
@@ -9547,11 +9757,14 @@ function capabilityReportToEvidence(report) {
   if (report.target.type !== "goal") return null;
   const evidence = report.evidence ?? {};
   const values = Object.values(evidence);
-  const status = values.some((value) => value === false) ? "fail" : values.length > 0 || report.facts ? "changed" : "noop";
+  const hasFalse = values.some((value) => value === false);
+  const hasTrue = values.some((value) => value === true);
+  const status = hasFalse ? "fail" : values.length > 0 || report.facts ? "changed" : "noop";
   return {
     version: 1,
     target: { type: "goal", id: report.target.id },
     status,
+    resultClass: hasFalse ? "needsFix" : hasTrue ? "succeeded" : "pending",
     summary: "capability reported goal evidence",
     evidence,
     facts: report.facts ?? {},
@@ -9570,9 +9783,10 @@ function capabilityResultToEvidence(result, fallbackGoalId, explicitEvidence) {
     version: 1,
     target: { type: "goal", id: targetId },
     status: result.status,
+    resultClass: result.resultClass ?? resultClassFromStatus(result.status),
     summary: result.summary,
-    evidence: result.evidence,
-    explicitEvidence: hasEvidenceValues ? void 0 : explicitEvidence,
+    ...result.evidence ? { evidence: result.evidence } : {},
+    ...hasEvidenceValues || !explicitEvidence ? {} : { explicitEvidence },
     facts: result.facts,
     artifacts: result.artifacts,
     missingEvidence: result.missingEvidence,
@@ -9604,6 +9818,7 @@ function mergeCapabilityEvidence(items) {
 function applyCapabilityEvidenceToGoalState(state, evidence) {
   const priorFacts = parseFacts3(state.extra.facts) ?? {};
   const nextFacts = { ...priorFacts };
+  const changesProgressState = evidence.sources.includes("result") || Object.entries(evidence.facts).some(([key, value]) => !CONTROL_FACT_KEYS3.has(key) && priorFacts[key] !== value) || Object.entries(evidence.evidence ?? {}).some(([key, value]) => priorFacts[key] !== value);
   for (const [key, value] of Object.entries(evidence.facts)) {
     if (CONTROL_FACT_KEYS3.has(key)) continue;
     nextFacts[key] = value;
@@ -9614,24 +9829,42 @@ function applyCapabilityEvidenceToGoalState(state, evidence) {
   const pending = typeof nextFacts.pendingEvidence === "string" ? nextFacts.pendingEvidence : "";
   const hasEvidenceValues = Object.keys(evidence.evidence ?? {}).length > 0;
   const statusEvidence = evidence.explicitEvidence || (hasEvidenceValues ? "" : pending);
+  const progressEvidence = statusEvidence || singleEvidenceKey(evidence.evidence);
+  const resultClass = evidence.resultClass ?? resultClassFromStatus(evidence.status);
   const hasPendingEvidenceValue = pending ? Object.hasOwn(evidence.evidence ?? {}, pending) : false;
-  const terminalStatus = evidence.status === "pass" || evidence.status === "fail" || evidence.status === "blocked";
+  const terminalResult = resultClass === "succeeded" || resultClass === "needsFix" || resultClass === "fatal";
   if (statusEvidence && !Object.hasOwn(evidence.evidence ?? {}, statusEvidence)) {
-    if (evidence.status === "pass") nextFacts[statusEvidence] = true;
-    if (evidence.status === "fail" || evidence.status === "blocked") nextFacts[statusEvidence] = false;
+    if (resultClass === "succeeded") nextFacts[statusEvidence] = true;
+    if (resultClass === "needsFix" || resultClass === "fatal") nextFacts[statusEvidence] = false;
   }
-  if (pending && (hasPendingEvidenceValue || statusEvidence === pending && terminalStatus)) {
+  if (pending && (hasPendingEvidenceValue || statusEvidence === pending && terminalResult)) {
     delete nextFacts.pendingEvidence;
   }
   const blockers = parseStringArray3(state.extra.blockers) ?? [];
-  const evidenceBlockers = evidence.blockers.length > 0 || evidence.status !== "fail" && evidence.status !== "blocked" ? evidence.blockers : [evidence.summary];
+  const evidenceBlockers = evidence.blockers.length > 0 || resultClass !== "needsFix" && resultClass !== "fatal" ? evidence.blockers : [evidence.summary];
   for (const blocker of evidenceBlockers) {
     if (!blockers.includes(blocker)) blockers.push(blocker);
   }
+  const evidenceState = parseGoalEvidenceState(state.extra.evidenceState);
+  const nextEvidenceState = progressEvidence && changesProgressState ? mergeGoalEvidenceProgress(evidenceState, progressEvidence, {
+    resultClass,
+    attempts: (evidenceState[progressEvidence]?.attempts ?? 0) + 1,
+    reason: evidence.summary,
+    nextAction: nextActionForResultClass(resultClass),
+    nextRetryAt: nextRetryAtFor(state, progressEvidence, resultClass),
+    updatedAt: nowIso()
+  }) : evidenceState;
   const nextExtra = {
     ...state.extra,
-    facts: nextFacts
+    facts: nextFacts,
+    ...changesProgressState ? {
+      reason: evidence.summary,
+      nextAction: progressEvidence ? nextEvidenceState[progressEvidence]?.nextAction : void 0
+    } : {}
   };
+  if (changesProgressState || state.extra.evidenceState !== void 0) {
+    nextExtra.evidenceState = nextEvidenceState;
+  }
   if (blockers.length > 0 || Array.isArray(state.extra.blockers)) {
     nextExtra.blockers = blockers;
   }
@@ -9640,6 +9873,13 @@ function applyCapabilityEvidenceToGoalState(state, evidence) {
     extra: nextExtra
   };
 }
+function resultClassFromStatus(status) {
+  if (status === "pass") return "succeeded";
+  if (status === "fail") return "needsFix";
+  if (status === "blocked") return "fatal";
+  if (status === "noop") return "pending";
+  return "pending";
+}
 function evidenceMatches(report, result, allReports) {
   if (report.target.id !== result.target.id) return false;
   if (result.explicitEvidence && Object.hasOwn(report.evidence ?? {}, result.explicitEvidence)) return true;
@@ -9652,6 +9892,7 @@ function evidenceMatches(report, result, allReports) {
 function mergeReportAndResult(report, result) {
   return {
     ...result,
+    resultClass: result.resultClass ?? report.resultClass,
     evidence: mergeOptionalRecords(report.evidence, result.evidence),
     facts: { ...report.facts, ...result.facts },
     artifacts: uniqueArtifacts([...report.artifacts, ...result.artifacts]),
@@ -9660,6 +9901,31 @@ function mergeReportAndResult(report, result) {
     sources: uniqueSources([...report.sources, ...result.sources])
   };
 }
+function singleEvidenceKey(evidence) {
+  const keys = Object.keys(evidence ?? {});
+  return keys.length === 1 ? keys[0] : "";
+}
+function nextActionForResultClass(resultClass) {
+  if (resultClass === "succeeded") return "continue";
+  if (resultClass === "pending") return "wait";
+  if (resultClass === "retryable") return "retry";
+  if (resultClass === "needsFix") return "create issue";
+  return "block";
+}
+function nextRetryAtFor(state, evidence, resultClass) {
+  if (resultClass !== "retryable") return void 0;
+  const delaySeconds = retryAfterSecondsFor(state.extra.route, evidence) ?? 300;
+  return new Date(Date.now() + delaySeconds * 1e3).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function retryAfterSecondsFor(route, evidence) {
+  if (!Array.isArray(route)) return void 0;
+  const step = route.find(
+    (item) => !!item && typeof item === "object" && !Array.isArray(item) && item.evidence === evidence
+  );
+  const policy = step && recordField4(step.onFailure);
+  const retryAfter = typeof policy?.retryAfterSeconds === "number" ? policy.retryAfterSeconds : void 0;
+  return retryAfter !== void 0 && retryAfter >= 0 ? Math.floor(retryAfter) : void 0;
+}
 function mergeOptionalRecords(left, right) {
   const merged = { ...left ?? {}, ...right ?? {} };
   return Object.keys(merged).length > 0 ? merged : void 0;
@@ -9705,10 +9971,15 @@ function parseStringArray3(raw) {
   }
   return out;
 }
+function recordField4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
 var CONTROL_FACT_KEYS3;
 var init_capabilityEvidence = __esm({
   "src/capabilityEvidence.ts"() {
     "use strict";
+    init_evidenceState();
+    init_state2();
     CONTROL_FACT_KEYS3 = /* @__PURE__ */ new Set(["blockers", "destination", "capabilities", "route", "stage", "state"]);
   }
 });
@@ -9745,6 +10016,7 @@ function capabilityEvidenceOutput(evidence) {
     kind: "capability-evidence",
     sources: evidence.sources,
     status: evidence.status,
+    resultClass: evidence.resultClass,
     summary: evidence.summary,
     evidence: evidence.evidence ?? {},
     facts: evidence.facts,
@@ -9756,7 +10028,7 @@ function capabilityEvidenceOutput(evidence) {
 function goalReportBody(goalId, state, snapshot, latestEvent, evidenceItems) {
   const outputs = evidenceItems.map(capabilityEvidenceOutput);
   const latestOutput = outputs.at(-1);
-  const facts = recordField4(snapshot, "facts") ?? recordField4(state.extra, "facts") ?? {};
+  const facts = recordField5(snapshot, "facts") ?? recordField5(state.extra, "facts") ?? {};
   const blockers = uniqueStrings2([
     ...stringArrayField(snapshot, "blockers"),
     ...stringArrayField(latestEvent, "blockers"),
@@ -9775,12 +10047,12 @@ function goalReportBody(goalId, state, snapshot, latestEvent, evidenceItems) {
     "",
     "## Status",
     `- State: ${state.state}`,
-    `- Stage: ${stringField4(snapshot, "stage") ?? stringField4(state.extra, "stage") ?? "unknown"}`,
+    `- Stage: ${stringField5(snapshot, "stage") ?? stringField5(state.extra, "stage") ?? "unknown"}`,
     `- Next step: ${nextStepFromEvent(state, snapshot, latestOutput, latestEvent)}`,
     `- Updated: ${state.updatedAt ?? state.createdAt ?? state.startedAt ?? "unknown"}`,
     "",
     "## Decision",
-    `- Event: ${stringField4(latestEvent, "event") ?? "unknown"}`,
+    `- Event: ${stringField5(latestEvent, "event") ?? "unknown"}`,
     `- Reason: ${decisionReason(state, latestEvent, latestOutput, missingEvidence, blockers)}`,
     `- Required evidence: ${listOrNone(stringArrayField(snapshot, "requiredEvidence"))}`,
     `- Satisfied evidence: ${listOrNone(stringArrayField(snapshot, "satisfiedEvidence"))}`,
@@ -9808,9 +10080,9 @@ function capabilityEvidenceMarkdown(outputs) {
 function decisionReason(state, latestEvent, latestOutput, missingEvidence, blockers) {
   if (state.state === "done") return "destination evidence satisfied";
   if (blockers.length > 0) return blockers[0] ?? "blocked";
-  const eventReason = stringField4(latestEvent, "reason") ?? stringField4(recordField4(latestEvent, "decision"), "reason");
+  const eventReason = stringField5(latestEvent, "reason") ?? stringField5(recordField5(latestEvent, "decision"), "reason");
   if (eventReason) return eventReason;
-  const summary = stringField4(latestOutput, "summary");
+  const summary = stringField5(latestOutput, "summary");
   if (summary) return summary;
   if (missingEvidence.length > 0) return `waiting for ${missingEvidence[0]}`;
   return "waiting for more evidence";
@@ -9818,33 +10090,33 @@ function decisionReason(state, latestEvent, latestOutput, missingEvidence, block
 function evidenceOutputMarkdown(index, output) {
   return [
     `### Output ${index}`,
-    `- Status: ${stringField4(output, "status") ?? "unknown"}`,
-    `- Summary: ${stringField4(output, "summary") ?? "no summary"}`,
+    `- Status: ${stringField5(output, "status") ?? "unknown"}`,
+    `- Summary: ${stringField5(output, "summary") ?? "no summary"}`,
     `- Sources: ${listOrNone(stringArrayField(output, "sources"))}`,
-    `- Evidence values: ${inlineJson(recordField4(output, "evidence") ?? {})}`,
+    `- Evidence values: ${inlineJson(recordField5(output, "evidence") ?? {})}`,
     `- Missing evidence: ${listOrNone(stringArrayField(output, "missingEvidence"))}`,
     `- Blockers: ${listOrNone(stringArrayField(output, "blockers"))}`,
     ""
   ];
 }
 function dispatchContextMarkdown(latestEvent) {
-  const context = recordField4(latestEvent, "dispatchContext");
+  const context = recordField5(latestEvent, "dispatchContext");
   if (!context) return ["- none"];
-  const githubActor = stringField4(context, "githubActor");
-  const githubActorRole = stringField4(context, "githubActorRole");
-  const target = dispatchTargetLabel(recordField4(context, "target"));
+  const githubActor = stringField5(context, "githubActor");
+  const githubActorRole = stringField5(context, "githubActorRole");
+  const target = dispatchTargetLabel(recordField5(context, "target"));
   return [
-    `- Triggered by: ${stringField4(context, "triggeredBy") ?? "unknown"}`,
-    `- Mode: ${stringField4(context, "dispatchMode") ?? "unknown"}`,
+    `- Triggered by: ${stringField5(context, "triggeredBy") ?? "unknown"}`,
+    `- Mode: ${stringField5(context, "dispatchMode") ?? "unknown"}`,
     `- GitHub actor: ${githubActor ? `${githubActor}${githubActorRole ? ` (${githubActorRole})` : ""}` : "none"}`,
-    `- Decided by: ${stringField4(context, "decidedBy") ?? "unknown"}`,
-    `- Dispatched by: ${stringField4(context, "dispatchedBy") ?? "unknown"}`,
+    `- Decided by: ${stringField5(context, "decidedBy") ?? "unknown"}`,
+    `- Dispatched by: ${stringField5(context, "dispatchedBy") ?? "unknown"}`,
     `- Target: ${target ?? "none"}`
   ];
 }
 function dispatchTargetLabel(target) {
-  const type = stringField4(target, "type");
-  const id = stringField4(target, "id");
+  const type = stringField5(target, "type");
+  const id = stringField5(target, "id");
   if (type && id) return `${type} ${id}`;
   return id ?? type;
 }
@@ -9867,11 +10139,11 @@ function listOrNone(values) {
 function uniqueStrings2(values) {
   return [...new Set(values)].sort();
 }
-function stringField4(record2, key) {
+function stringField5(record2, key) {
   const value = record2?.[key];
   return typeof value === "string" && value.trim() ? value : void 0;
 }
-function recordField4(record2, key) {
+function recordField5(record2, key) {
   const value = record2?.[key];
   return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : void 0;
 }
@@ -9904,7 +10176,7 @@ ${artifact.path ?? ""}`;
 }
 function nextStepFromEvent(state, goalAfter, capabilityOutput, latestEvent) {
   if (state.state === "done") return "done";
-  const decisionKind = stringField4(recordField4(latestEvent, "decision"), "kind") ?? stringField4(latestEvent, "status");
+  const decisionKind = stringField5(recordField5(latestEvent, "decision"), "kind") ?? stringField5(latestEvent, "status");
   if (decisionKind === "done") return "done";
   if (decisionKind === "dispatch") return "dispatch";
   if (decisionKind === "blocked" || decisionKind === "reject-evidence") return "block";
@@ -9954,6 +10226,64 @@ var init_report = __esm({
 });
 
 // src/scripts/applyCapabilityReports.ts
+function ensureNeedsFixIssue(ctx, goalId, state, evidence, evidenceKey) {
+  if (evidence.resultClass !== "needsFix" || !evidenceKey) return state;
+  const evidenceState = parseGoalEvidenceState(state.extra.evidenceState);
+  const progress = evidenceState[evidenceKey];
+  if (progress?.issue) return state;
+  const issue = findExistingNeedsFixIssue(goalId, evidenceKey, ctx.cwd) ?? createNeedsFixIssue(goalId, evidenceKey, evidence, ctx.cwd);
+  const nextEvidenceState = mergeGoalEvidenceProgress(evidenceState, evidenceKey, {
+    resultClass: "needsFix",
+    attempts: progress?.attempts ?? 1,
+    reason: evidence.summary,
+    nextAction: `fix issue #${issue}`,
+    issue,
+    updatedAt: nowIso()
+  });
+  return {
+    ...state,
+    extra: {
+      ...state.extra,
+      evidenceState: nextEvidenceState,
+      reason: evidence.summary,
+      nextAction: `fix issue #${issue}`
+    }
+  };
+}
+function evidenceKeyFromOutput(evidence, beforeSnapshot) {
+  if (evidence.explicitEvidence) return evidence.explicitEvidence;
+  const keys = Object.keys(evidence.evidence ?? {});
+  if (keys.length === 1) return keys[0];
+  const pending = beforeSnapshot?.pendingEvidence;
+  return typeof pending === "string" ? pending : "";
+}
+function needsFixIssueMarker(goalId, evidence) {
+  return `<!-- kody-managed-goal-needs-fix: ${goalId}:${evidence} -->`;
+}
+function findExistingNeedsFixIssue(goalId, evidence, cwd) {
+  const marker = needsFixIssueMarker(goalId, evidence);
+  const raw = gh(["issue", "list", "--state", "all", "--limit", "100", "--json", "number,body"], { cwd });
+  const issues = JSON.parse(raw);
+  const match = issues.find((issue) => typeof issue.number === "number" && issue.body?.includes(marker));
+  return match?.number ?? null;
+}
+function createNeedsFixIssue(goalId, evidence, result, cwd) {
+  const title = `Goal ${goalId}: fix ${evidence}`.slice(0, 120);
+  const body = [
+    `Managed goal: \`${goalId}\``,
+    `Evidence: \`${evidence}\``,
+    "",
+    `Reason: ${result.summary}`,
+    "",
+    result.blockers.length > 0 ? `Blockers: ${result.blockers.join(", ")}` : "Blockers: none",
+    "",
+    needsFixIssueMarker(goalId, evidence)
+  ].join("\n");
+  const out = gh(["issue", "create", "--title", title, "--body-file", "-"], { input: body, cwd });
+  const match = out.match(/\/issues\/(\d+)(?:[/?#]|$)/);
+  if (!match) throw new Error(`gh issue create returned unexpected output: ${out}`);
+  return Number(match[1]);
+}
 function flushLogs(ctx) {
   try {
     flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
@@ -10046,15 +10376,13 @@ function completeSatisfiedManagedGoal(state) {
   if (decision.kind !== "done") return state;
   return writeManagedGoalToState({ ...state, state: "done" }, managed);
 }
-function shouldResumeManagedGoal(state) {
+function shouldResumeManagedGoal(goalId, state) {
   if (state.state !== "active") return false;
   const managed = managedGoalFromState(state);
   if (!managed) return false;
   if (managed.blockers.length > 0) return false;
-  const missing = managed.destination.evidence.find((evidence) => managed.facts[evidence] !== true);
-  if (!missing) return false;
-  const step = managed.route.find((candidate) => candidate.evidence === missing);
-  return Boolean(step && managed.capabilities.includes(step.capability));
+  if (managed.facts.goalId === void 0) managed.facts.goalId = goalId;
+  return planManagedGoalTick(managed).kind === "dispatch";
 }
 function snapshotFromState2(goalId, state) {
   const managed = managedGoalFromState(state);
@@ -10111,11 +10439,13 @@ var init_applyCapabilityReports = __esm({
     init_capabilityEvidence();
     init_capabilityReport();
     init_capabilityResult();
+    init_evidenceState();
     init_manager();
     init_report();
     init_runLog();
     init_state2();
     init_stateStore();
+    init_issue();
     applyCapabilityReports = async (ctx, _profile, agentResult) => {
       const reports = collectReports(ctx.data.capabilityReports, agentResult);
       const results = collectResults(ctx.data.capabilityResults ?? ctx.data.dutyResults, agentResult);
@@ -10153,6 +10483,7 @@ var init_applyCapabilityReports = __esm({
         for (const evidence of goalEvidence) {
           const beforeSnapshot = snapshotFromState2(goalId, next);
           next = applyCapabilityEvidenceToGoalState(next, evidence);
+          next = ensureNeedsFixIssue(ctx, goalId, next, evidence, evidenceKeyFromOutput(evidence, beforeSnapshot));
           const afterSnapshot = snapshotFromState2(goalId, next);
           const change = goalRunLogChange(beforeSnapshot, afterSnapshot);
           const output = capabilityEvidenceOutput(evidence);
@@ -10203,7 +10534,7 @@ var init_applyCapabilityReports = __esm({
             putGoalState(ctx.config, goalId, nextForOutput, describeMessage(goalId, goalEvidence), ctx.cwd);
           }
           refreshReportOrFail(ctx, goalId, nextForOutput, goalEvidence);
-          if (changed && ctx.output.exitCode === 0 && !ctx.output.nextDispatch && shouldResumeManagedGoal(nextForOutput)) {
+          if (changed && ctx.output.exitCode === 0 && !ctx.output.nextDispatch && shouldResumeManagedGoal(goalId, nextForOutput)) {
             ctx.output.nextDispatch = {
               action: "goal-manager",
               executable: "goal-manager",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.321",
+  "version": "0.4.322",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",