@kody-ade/kody-engine 0.4.323 → 0.4.325

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.323",
+      version: "0.4.325",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -6392,6 +6392,224 @@ var init_litellm = __esm({
   }
 });
 
+// src/runIndex.ts
+function upsertRunIndexRow(config, cwd, row) {
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    const current = readStateText(config, cwd, RUN_INDEX_PATH);
+    const next = mergeRunIndexRow(current?.content, row);
+    try {
+      writeStateText(
+        config,
+        cwd,
+        RUN_INDEX_PATH,
+        JSON.stringify(next, null, 2),
+        "chore(runs): update run index",
+        current?.sha
+      );
+      return;
+    } catch (err) {
+      if (!isConflict(err) || attempt === 3) throw err;
+    }
+  }
+}
+function upsertRunIndexRowBestEffort(config, cwd, row) {
+  if (!row) return;
+  try {
+    upsertRunIndexRow(config, cwd, row);
+  } catch (err) {
+    process.stderr.write(`[kody runs] index update failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+function mergeRunIndexRow(raw, row) {
+  const parsed = parseRunIndex(raw);
+  const runs = [row, ...parsed.runs.filter((existing) => existing.id !== row.id)].slice(0, MAX_RUNS);
+  return {
+    version: 1,
+    updatedAt: row.updatedAt,
+    runs
+  };
+}
+function runIndexRowFromJobContext(input) {
+  const subjectType = runSubjectType(input.data);
+  const subjectId = stringValue2(input.data.runSubjectId);
+  if (!subjectType || !subjectId) return null;
+  const kodyRunId = stringValue2(input.data.jobId) ?? `${input.profileName}-${Date.now()}`;
+  const workflow = stringValue2(input.data.runSubjectWorkflow) ?? stringValue2(input.data.workflowCapability);
+  const title = stringValue2(input.data.runSubjectLabel) ?? subjectId;
+  const githubRunId2 = process.env.GITHUB_RUN_ID?.trim() || void 0;
+  const githubRunAttempt = process.env.GITHUB_RUN_ATTEMPT?.trim() || void 0;
+  const githubRepository = process.env.GITHUB_REPOSITORY?.trim();
+  const githubServer = process.env.GITHUB_SERVER_URL?.trim() || "https://github.com";
+  const triggerKind2 = triggerKindFromEnv();
+  return pruneUndefined({
+    version: 1,
+    id: `${subjectType}:${subjectId}:${kodyRunId}`,
+    subjectType,
+    subjectId,
+    subjectLabel: title,
+    subjectModel: stringValue2(input.data.runSubjectModel) ?? void 0,
+    status: input.status,
+    title,
+    summary: input.reason ?? stringValue2(input.data.workflowStepReason) ?? input.profile.describe,
+    currentStep: stringValue2(input.data.workflowStep) ?? input.profileName,
+    startedAt: input.startedAt,
+    updatedAt: input.updatedAt,
+    kodyRunId,
+    githubRunId: githubRunId2,
+    githubRunAttempt,
+    githubRunUrl: githubRunId2 && githubRepository ? `${githubServer}/${githubRepository}/actions/runs/${githubRunId2}` : void 0,
+    triggerKind: triggerKind2,
+    triggerMode: triggerMode(triggerKind2),
+    actor: process.env.GITHUB_ACTOR?.trim() || void 0,
+    action: stringValue2(input.data.jobAction) ?? void 0,
+    capability: stringValue2(input.data.jobCapability) ?? void 0,
+    workflow: workflow ?? void 0,
+    executable: stringValue2(input.data.jobExecutable) ?? input.profileName,
+    agent: stringValue2(input.data.jobAgent) ?? input.profile.agent ?? void 0,
+    model: stringValue2(input.data.jobModel) ?? void 0,
+    modelProvider: stringValue2(input.data.jobModelProvider) ?? void 0,
+    modelName: stringValue2(input.data.jobModelName) ?? void 0,
+    reasoningEffort: stringValue2(input.data.jobReasoningEffort) ?? void 0,
+    target: input.data.jobTarget,
+    sourceType: "job"
+  });
+}
+function runIndexRowFromGoalEvents(goalId, logPath, events) {
+  if (events.length === 0) return null;
+  const first = events[0];
+  const last = events[events.length - 1];
+  const goal = recordValue2(last.goal) ?? recordValue2(first.goal);
+  const goalType = stringValue2(last.goalType) ?? stringValue2(first.goalType) ?? stringValue2(goal?.type);
+  const subjectType = goalType === "agentLoop" ? "loop" : "goal";
+  const run = recordValue2(first.run) ?? recordValue2(last.run);
+  const job = recordValue2(last.job) ?? recordValue2(first.job);
+  const trigger = recordValue2(last.trigger) ?? recordValue2(first.trigger);
+  const links = recordValue2(last.links) ?? recordValue2(first.links);
+  const decision = recordValue2(last.decision);
+  const trace = recordValue2(last.trace);
+  const traceResult = recordValue2(trace?.result);
+  const kodyRunId = stringValue2(run?.id) ?? stringValue2(job?.id) ?? logPath;
+  const updatedAt = stringValue2(last.time) ?? (/* @__PURE__ */ new Date()).toISOString();
+  return pruneUndefined({
+    version: 1,
+    id: `${subjectType}:${goalId}:${kodyRunId}`,
+    subjectType,
+    subjectId: goalId,
+    subjectLabel: goalId,
+    subjectModel: goalType ?? void 0,
+    status: statusFromGoalEvent(last, decision),
+    title: goalId,
+    summary: stringValue2(last.summary) ?? stringValue2(last.reason) ?? stringValue2(traceResult?.summary) ?? stringValue2(last.event) ?? void 0,
+    currentStep: stringValue2(last.stage) ?? stringValue2(goal?.stage) ?? stringValue2(last.event) ?? void 0,
+    decision: [stringValue2(decision?.kind), stringValue2(decision?.reason) ?? stringValue2(last.reason)].filter(Boolean).join(" - ") || void 0,
+    startedAt: stringValue2(first.time) ?? void 0,
+    updatedAt,
+    kodyRunId,
+    githubRunId: stringValue2(run?.githubRunId) ?? void 0,
+    githubRunAttempt: stringValue2(run?.githubRunAttempt) ?? void 0,
+    githubRunUrl: stringValue2(links?.workflowRun) ?? stringValue2(run?.url) ?? void 0,
+    triggerKind: stringValue2(trigger?.kind) ?? void 0,
+    triggerMode: triggerMode(stringValue2(trigger?.kind)),
+    actor: stringValue2(trigger?.githubActor) ?? stringValue2(trigger?.actor) ?? void 0,
+    action: stringValue2(job?.action) ?? void 0,
+    capability: stringValue2(job?.capability) ?? void 0,
+    executable: stringValue2(job?.executable) ?? void 0,
+    agent: stringValue2(job?.agent) ?? void 0,
+    model: stringValue2(job?.model) ?? void 0,
+    modelProvider: stringValue2(job?.modelProvider) ?? void 0,
+    modelName: stringValue2(job?.modelName) ?? void 0,
+    reasoningEffort: stringValue2(job?.reasoningEffort) ?? void 0,
+    target: last.target,
+    sourceType: "goal-run-log",
+    sourcePath: logPath,
+    detailUrl: stringValue2(links?.log) ?? void 0,
+    statePath: stringValue2(recordValue2(last.stateRepo)?.goalStatePath) ?? void 0
+  });
+}
+function statusFromExitCode(exitCode) {
+  return exitCode === 0 ? "success" : "failed";
+}
+function parseRunIndex(raw) {
+  if (!raw) return { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), runs: [] };
+  try {
+    const parsed = JSON.parse(raw);
+    const record2 = recordValue2(parsed);
+    const runs = Array.isArray(record2?.runs) ? record2.runs.filter(isRunIndexRow).map(normalizeRunIndexRow) : [];
+    return { version: 1, updatedAt: stringValue2(record2?.updatedAt) ?? (/* @__PURE__ */ new Date()).toISOString(), runs };
+  } catch {
+    return { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), runs: [] };
+  }
+}
+function isRunIndexRow(value) {
+  const record2 = recordValue2(value);
+  return record2?.version === 1 && isRunSubjectType(record2.subjectType) && typeof record2.subjectId === "string" && typeof record2.id === "string" && typeof record2.status === "string" && typeof record2.title === "string" && typeof record2.updatedAt === "string";
+}
+function isRunSubjectType(value) {
+  return value === "goal" || value === "loop" || value === "workflow";
+}
+function normalizeRunIndexRow(row) {
+  if (row.status === "running" && (row.decision?.toLowerCase().startsWith("dispatch") || row.summary?.toLowerCase().startsWith("dispatch") || row.currentStep?.toLowerCase().includes("dispatch"))) {
+    return { ...row, status: "waiting" };
+  }
+  return row;
+}
+function runSubjectType(data) {
+  const value = data.runSubjectType;
+  return isRunSubjectType(value) ? value : null;
+}
+function statusFromGoalEvent(event, decision) {
+  const status = stringValue2(event.status)?.toLowerCase();
+  const eventName = stringValue2(event.event)?.toLowerCase() ?? "";
+  const decisionKind = stringValue2(decision?.kind)?.toLowerCase();
+  if (status === "success" || status === "completed" || decisionKind === "done") return "success";
+  if (status === "failure" || status === "failed" || eventName.includes("fail")) return "failed";
+  if (status === "cancelled") return "cancelled";
+  if (decisionKind === "blocked") return "blocked";
+  if (status === "dispatch" || decisionKind === "dispatch" || eventName.includes("dispatch")) return "waiting";
+  if (status === "running") return "running";
+  return "recorded";
+}
+function triggerKindFromEnv() {
+  const eventName = process.env.GITHUB_EVENT_NAME?.trim();
+  if (!eventName) return void 0;
+  if (eventName === "schedule") return "schedule";
+  if (eventName === "workflow_dispatch") return "manual-workflow-dispatch";
+  return eventName;
+}
+function triggerMode(kind) {
+  if (!kind) return void 0;
+  if (kind === "schedule") return "scheduled";
+  if (kind === "manual-workflow-dispatch") return "manual";
+  if (kind === "local") return "local";
+  return "event";
+}
+function isConflict(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /HTTP 409/i.test(msg) || /HTTP 422/i.test(msg) || /does not match|is at|but expected/i.test(msg);
+}
+function recordValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function pruneUndefined(input) {
+  for (const key of Object.keys(input)) {
+    if (input[key] === void 0) delete input[key];
+  }
+  return input;
+}
+var RUN_INDEX_PATH, MAX_RUNS;
+var init_runIndex = __esm({
+  "src/runIndex.ts"() {
+    "use strict";
+    init_stateRepo();
+    RUN_INDEX_PATH = "runs/index.json";
+    MAX_RUNS = 200;
+  }
+});
+
 // src/pushWithRetry.ts
 import { execFileSync as execFileSync6 } from "child_process";
 function sleepSync2(ms) {
@@ -6904,6 +7122,32 @@ function planManagedGoalTick(goal) {
     goal.nextAction = "done";
     return { kind: "done" };
   }
+  const workflow = goal.workflowRef;
+  if (workflow) {
+    const workflowStep = { evidence: missing, stage: "workflow", capability: workflow.id };
+    const progressDecision2 = decisionFromEvidenceProgress(goal, workflowStep, missing);
+    if (progressDecision2) return progressDecision2;
+    const resolved2 = resolveWorkflowRefArgs(goal, workflow);
+    if (!resolved2.ok) {
+      goal.stage = "blocked";
+      goal.reason = resolved2.reason;
+      goal.nextAction = "fix workflow args";
+      pushBlocker(goal, resolved2.reason);
+      return { kind: "blocked", evidence: missing, stage: "workflow", reason: resolved2.reason };
+    }
+    goal.stage = "workflow";
+    goal.facts.pendingEvidence = missing;
+    goal.reason = `dispatch workflow ${workflow.id} for ${missing}`;
+    goal.nextAction = "dispatch workflow";
+    return {
+      kind: "dispatchWorkflow",
+      evidence: missing,
+      stage: "workflow",
+      workflow: workflow.id,
+      cliArgs: resolved2.cliArgs,
+      ...workflow.saveReport === true ? { saveReport: true } : {}
+    };
+  }
   const step = goal.route.find((candidate) => candidate.evidence === missing);
   if (!step) {
     if (isSimpleGoal(goal) && missing === SIMPLE_GOAL_EVIDENCE) {
@@ -6959,6 +7203,15 @@ function planManagedGoalTick(goal) {
     ...step.saveReport === true ? { saveReport: true } : {}
   };
 }
+function resolveWorkflowRefArgs(goal, workflow) {
+  const step = {
+    evidence: "__workflow__",
+    stage: "workflow",
+    capability: workflow.id,
+    args: workflow.args
+  };
+  return resolveRouteArgs(goal, step);
+}
 function decisionFromEvidenceProgress(goal, step, evidence) {
   const progress = goal.evidenceState?.[evidence];
   if (!progress) return null;
@@ -7095,6 +7348,19 @@ function asLoopTarget(value) {
   if (typeof raw.id !== "string" || raw.id.trim().length === 0) return void 0;
   return { type: raw.type, id: raw.id };
 }
+function asWorkflowRef(value) {
+  const raw = asRecord(value);
+  if (!raw) return void 0;
+  if (typeof raw.id !== "string" || raw.id.trim().length === 0) return void 0;
+  const args = raw.args === void 0 ? void 0 : asRecord(raw.args);
+  if (raw.args !== void 0 && !args) return void 0;
+  return {
+    id: raw.id.trim(),
+    ...typeof raw.source === "string" && raw.source.trim().length > 0 ? { source: raw.source.trim() } : {},
+    ...args ? { args } : {},
+    ...raw.saveReport === true ? { saveReport: true } : {}
+  };
+}
 function managedGoalFromState(state) {
   const extra = state.extra;
   const destination = asRecord(extra.destination);
@@ -7111,6 +7377,7 @@ function managedGoalFromState(state) {
     destination: { outcome: destination.outcome, evidence },
     capabilities,
     route,
+    workflowRef: asWorkflowRef(extra.workflowRef),
     schedule: typeof extra.schedule === "string" ? extra.schedule : void 0,
     preferredRunTime: asPreferredRunTime(extra.preferredRunTime),
     loopTarget: asLoopTarget(extra.loopTarget),
@@ -7131,6 +7398,7 @@ function writeManagedGoalToState(state, goal) {
       destination: goal.destination,
       capabilities: goal.capabilities,
       route: goal.route,
+      workflowRef: goal.workflowRef,
       stage: goal.stage,
       facts: goal.facts,
       blockers: goal.blockers,
@@ -7220,9 +7488,15 @@ function flushGoalRunLogEvents(config, cwd, data) {
   const logs = goalRunLogs(data);
   for (const [goalId, log2] of Object.entries(logs)) {
     if (log2.events.length === 0) continue;
-    const lines = `${log2.events.map((event) => JSON.stringify(enrichGoalRunLogEvent(config, data, log2.path, event))).join("\n")}
+    const enrichedEvents = log2.events.map((event) => enrichGoalRunLogEvent(config, data, log2.path, event));
+    const lines = `${enrichedEvents.map((event) => JSON.stringify(event)).join("\n")}
 `;
     appendStateLine(config, cwd, log2.path, lines, `chore(goal-logs): append ${goalId}`);
+    upsertRunIndexRowBestEffort(
+      config,
+      cwd,
+      runIndexRowFromGoalEvents(goalId, log2.path, enrichedEvents)
+    );
     log2.events = [];
   }
 }
@@ -7250,6 +7524,7 @@ function goalRunLogSnapshot(goalId, goalState, goal) {
     pendingEvidence,
     capabilities: [...goal.capabilities],
     route: goal.route.map(routeStepForLog),
+    workflowRef: goal.workflowRef,
     schedule: goal.schedule,
     preferredRunTime: goal.preferredRunTime,
     loopTarget: goal.loopTarget,
@@ -7264,8 +7539,8 @@ function goalRunLogChange(before, after) {
   addScalarChange(change, "state", before.state, after.state);
   addScalarChange(change, "stage", before.stage, after.stage);
   addScalarChange(change, "pendingEvidence", before.pendingEvidence, after.pendingEvidence);
-  const beforeFacts = recordValue2(before.facts);
-  const afterFacts = recordValue2(after.facts);
+  const beforeFacts = recordValue3(before.facts);
+  const afterFacts = recordValue3(after.facts);
   if (beforeFacts || afterFacts) change.facts = diffRecordKeys(beforeFacts ?? {}, afterFacts ?? {});
   const beforeBlockers = stringArrayValue(before.blockers);
   const afterBlockers = stringArrayValue(after.blockers);
@@ -7279,8 +7554,8 @@ 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);
+  const beforeEvidenceState = recordValue3(before.evidenceState);
+  const afterEvidenceState = recordValue3(after.evidenceState);
   if (beforeEvidenceState || afterEvidenceState) {
     change.evidenceState = diffRecordKeys(beforeEvidenceState ?? {}, afterEvidenceState ?? {});
   }
@@ -7305,7 +7580,7 @@ function goalRunStartedAt(data) {
 function goalRunId(data) {
   const existing = data[LOG_RUN_KEY];
   if (typeof existing === "string" && existing.length > 0) return existing;
-  const raw = stringValue2(data.jobId) ?? githubRunId() ?? `local-${process.pid}-${Date.now()}`;
+  const raw = stringValue3(data.jobId) ?? githubRunId() ?? `local-${process.pid}-${Date.now()}`;
   const safe = safePathSegment(raw);
   data[LOG_RUN_KEY] = safe;
   return safe;
@@ -7337,7 +7612,7 @@ function enrichGoalRunLogEvent(config, data, logPath, event) {
   const job = event.job ?? jobContext(data);
   const run = event.run ?? runContext(data);
   const links = event.links ?? linkContext(stateRepo);
-  const enriched = pruneUndefined({
+  const enriched = pruneUndefined2({
     ...event,
     run,
     repo: event.repo ?? repoContext(config),
@@ -7351,23 +7626,23 @@ function enrichGoalRunLogEvent(config, data, logPath, event) {
   return enriched;
 }
 function goalRunTrace(event) {
-  const run = recordValue2(event.run);
-  const trigger = recordValue2(event.trigger);
-  const goal = recordValue2(event.goal);
-  const inspection = recordValue2(event.inspection);
-  const capabilityOutput = recordValue2(inspection?.capabilityOutput);
-  return pruneUndefined({
+  const run = recordValue3(event.run);
+  const trigger = recordValue3(event.trigger);
+  const goal = recordValue3(event.goal);
+  const inspection = recordValue3(event.inspection);
+  const capabilityOutput = recordValue3(inspection?.capabilityOutput);
+  return pruneUndefined2({
     version: 1,
-    runId: stringValue2(run?.id) ?? void 0,
-    workflowRunId: stringValue2(run?.githubRunId) ?? void 0,
-    triggerKind: stringValue2(trigger?.kind) ?? void 0,
+    runId: stringValue3(run?.id) ?? void 0,
+    workflowRunId: stringValue3(run?.githubRunId) ?? void 0,
+    triggerKind: stringValue3(trigger?.kind) ?? void 0,
     source: event.source,
     event: event.event,
-    goal: pruneUndefined({
+    goal: pruneUndefined2({
       id: event.goalId,
-      type: event.goalType ?? stringValue2(goal?.type) ?? void 0,
-      state: event.goalState ?? stringValue2(goal?.state) ?? void 0,
-      stage: event.stage ?? stringValue2(goal?.stage) ?? void 0
+      type: event.goalType ?? stringValue3(goal?.type) ?? void 0,
+      state: event.goalState ?? stringValue3(goal?.state) ?? void 0,
+      stage: event.stage ?? stringValue3(goal?.stage) ?? void 0
     }),
     evidence: goalTraceEvidence(event, goal, inspection),
     capability: event.dispatch ?? capabilityDispatchFromOutput(capabilityOutput),
@@ -7377,30 +7652,30 @@ function goalRunTrace(event) {
   });
 }
 function goalTraceEvidence(event, goal, inspection) {
-  const expectedEvidence = recordValue2(inspection?.expectedEvidence);
-  const out = pruneUndefined({
+  const expectedEvidence = recordValue3(inspection?.expectedEvidence);
+  const out = pruneUndefined2({
     current: event.evidence,
     required: stringArrayValue(goal?.requiredEvidence) ?? stringArrayValue(inspection?.requiredEvidence) ?? void 0,
     satisfied: stringArrayValue(goal?.satisfiedEvidence) ?? stringArrayValue(inspection?.satisfiedEvidence) ?? void 0,
     missing: stringArrayValue(goal?.missingEvidence) ?? stringArrayValue(inspection?.missingEvidence) ?? stringArrayValue(expectedEvidence?.missingBefore) ?? void 0,
-    pending: stringValue2(goal?.pendingEvidence) ?? stringValue2(inspection?.pendingEvidence) ?? stringValue2(expectedEvidence?.pendingBefore) ?? void 0,
+    pending: stringValue3(goal?.pendingEvidence) ?? stringValue3(inspection?.pendingEvidence) ?? stringValue3(expectedEvidence?.pendingBefore) ?? void 0,
     values: event.evidenceValues
   });
   return Object.keys(out).length > 0 ? out : void 0;
 }
 function capabilityDispatchFromOutput(output) {
   if (!output) return void 0;
-  const dispatch2 = pruneUndefined({
-    capability: stringValue2(output.capability) ?? void 0,
-    executable: stringValue2(output.executable) ?? void 0,
-    action: stringValue2(output.action) ?? void 0
+  const dispatch2 = pruneUndefined2({
+    capability: stringValue3(output.capability) ?? void 0,
+    executable: stringValue3(output.executable) ?? void 0,
+    action: stringValue3(output.action) ?? void 0
   });
   return Object.keys(dispatch2).length > 0 ? dispatch2 : void 0;
 }
 function goalTraceResult(event, capabilityOutput) {
-  const result = pruneUndefined({
-    status: event.status ?? stringValue2(capabilityOutput?.status) ?? void 0,
-    summary: event.reason ?? stringValue2(capabilityOutput?.summary) ?? void 0,
+  const result = pruneUndefined2({
+    status: event.status ?? stringValue3(capabilityOutput?.status) ?? void 0,
+    summary: event.reason ?? stringValue3(capabilityOutput?.summary) ?? void 0,
     blockers: event.inspection ? stringArrayValue(capabilityOutput?.blockers) ?? void 0 : void 0,
     artifacts: event.artifacts
   });
@@ -7411,7 +7686,7 @@ function runContext(data) {
   const attempt = process.env.GITHUB_RUN_ATTEMPT?.trim();
   const repository = process.env.GITHUB_REPOSITORY?.trim();
   const server = process.env.GITHUB_SERVER_URL?.trim() || "https://github.com";
-  return pruneUndefined({
+  return pruneUndefined2({
     id: goalRunId(data),
     provider: runId ? "github-actions" : "local",
     githubRunId: runId || void 0,
@@ -7425,7 +7700,7 @@ function runContext(data) {
 function repoContext(config) {
   const owner = config.github?.owner;
   const repo = config.github?.repo;
-  return pruneUndefined({
+  return pruneUndefined2({
     owner,
     repo,
     fullName: owner && repo ? `${owner}/${repo}` : process.env.GITHUB_REPOSITORY?.trim() || void 0,
@@ -7449,11 +7724,11 @@ function stateRepoContext(config, goalId, logPath) {
 }
 function triggerContext() {
   const event = readGithubEvent();
-  const inputs = recordValue2(event?.inputs);
+  const inputs = recordValue3(event?.inputs);
   const eventName = process.env.GITHUB_EVENT_NAME?.trim() || void 0;
   const githubActor = process.env.GITHUB_ACTOR?.trim() || void 0;
   if (!eventName && !githubActor && !process.env.GITHUB_EVENT_PATH) return void 0;
-  const trigger = pruneUndefined({
+  const trigger = pruneUndefined2({
     source: eventName ? "github-actions" : "local",
     kind: triggerKind(eventName),
     eventName,
@@ -7461,10 +7736,10 @@ function triggerContext() {
     githubActor,
     actorRole: triggerActorRole(eventName),
     eventPath: process.env.GITHUB_EVENT_PATH?.trim() || void 0,
-    issue: numberValue(recordValue2(event?.issue)?.number),
-    pullRequest: numberValue(recordValue2(event?.pull_request)?.number),
-    comment: numberValue(recordValue2(event?.comment)?.id),
-    schedule: stringValue2(event?.schedule),
+    issue: numberValue(recordValue3(event?.issue)?.number),
+    pullRequest: numberValue(recordValue3(event?.pull_request)?.number),
+    comment: numberValue(recordValue3(event?.comment)?.id),
+    schedule: stringValue3(event?.schedule),
     inputs: inputs ? pickRecord(inputs, ["issue_number", "sessionId", "message", "model", "title", "executable", "base"]) : void 0
   });
   return Object.keys(trigger).length > 0 ? trigger : void 0;
@@ -7482,17 +7757,21 @@ function triggerActorRole(eventName) {
   return "github event actor";
 }
 function jobContext(data) {
-  const job = pruneUndefined({
-    id: stringValue2(data.jobId) ?? void 0,
-    key: stringValue2(data.jobKey) ?? void 0,
-    flavor: stringValue2(data.jobFlavor) ?? void 0,
-    action: stringValue2(data.jobAction) ?? void 0,
-    capability: stringValue2(data.jobCapability) ?? void 0,
-    executable: stringValue2(data.jobExecutable) ?? void 0,
-    agent: stringValue2(data.jobAgent) ?? void 0,
-    schedule: stringValue2(data.jobSchedule) ?? void 0,
+  const job = pruneUndefined2({
+    id: stringValue3(data.jobId) ?? void 0,
+    key: stringValue3(data.jobKey) ?? void 0,
+    flavor: stringValue3(data.jobFlavor) ?? void 0,
+    action: stringValue3(data.jobAction) ?? void 0,
+    capability: stringValue3(data.jobCapability) ?? void 0,
+    executable: stringValue3(data.jobExecutable) ?? void 0,
+    agent: stringValue3(data.jobAgent) ?? void 0,
+    schedule: stringValue3(data.jobSchedule) ?? void 0,
     target: data.jobTarget ?? void 0,
-    why: truncateString(stringValue2(data.jobWhy), 1e3),
+    model: stringValue3(data.jobModel) ?? void 0,
+    modelProvider: stringValue3(data.jobModelProvider) ?? void 0,
+    modelName: stringValue3(data.jobModelName) ?? void 0,
+    reasoningEffort: stringValue3(data.jobReasoningEffort) ?? void 0,
+    why: truncateString(stringValue3(data.jobWhy), 1e3),
     saveReport: data.jobSaveReport === true ? true : void 0
   });
   return Object.keys(job).length > 0 ? job : void 0;
@@ -7500,23 +7779,23 @@ function jobContext(data) {
 function dispatchContext(event, trigger, job) {
   if (!event.dispatch && event.status !== "dispatch") return void 0;
   const dispatch2 = event.dispatch ?? {};
-  const context = pruneUndefined({
+  const context = pruneUndefined2({
     triggeredBy: triggerLabel(trigger),
-    triggerKind: stringValue2(trigger?.kind),
+    triggerKind: stringValue3(trigger?.kind),
     dispatchMode: dispatchMode(trigger),
-    githubActor: stringValue2(trigger?.githubActor) ?? stringValue2(trigger?.actor),
-    githubActorRole: stringValue2(trigger?.actorRole),
+    githubActor: stringValue3(trigger?.githubActor) ?? stringValue3(trigger?.actor),
+    githubActorRole: stringValue3(trigger?.actorRole),
     decidedBy: event.source,
     dispatchedBy: event.source,
     target: event.target,
-    action: dispatch2.action ?? stringValue2(job?.action),
-    capability: dispatch2.capability ?? stringValue2(job?.capability),
+    action: dispatch2.action ?? stringValue3(job?.action),
+    capability: dispatch2.capability ?? stringValue3(job?.capability),
     reason: event.reason
   });
   return Object.keys(context).length > 0 ? context : void 0;
 }
 function triggerLabel(trigger) {
-  const kind = stringValue2(trigger?.kind);
+  const kind = stringValue3(trigger?.kind);
   if (kind === "schedule") return "GitHub schedule";
   if (kind === "manual-workflow-dispatch") return "manual workflow dispatch";
   if (kind === "issue_comment") return "GitHub issue comment";
@@ -7525,7 +7804,7 @@ function triggerLabel(trigger) {
   return "local run";
 }
 function dispatchMode(trigger) {
-  const kind = stringValue2(trigger?.kind);
+  const kind = stringValue3(trigger?.kind);
   if (kind === "schedule") return "automated";
   if (kind === "manual-workflow-dispatch") return "manual";
   if (kind) return "event-driven";
@@ -7537,10 +7816,10 @@ function linkContext(stateRepo) {
   const repository = process.env.GITHUB_REPOSITORY?.trim();
   const server = process.env.GITHUB_SERVER_URL?.trim() || "https://github.com";
   if (runId && repository) links.workflowRun = `${server}/${repository}/actions/runs/${runId}`;
-  const repo = stringValue2(stateRepo?.repo);
-  const branch = stringValue2(stateRepo?.branch);
-  const goalStatePath2 = stringValue2(stateRepo?.goalStatePath);
-  const logPath = stringValue2(stateRepo?.logPath);
+  const repo = stringValue3(stateRepo?.repo);
+  const branch = stringValue3(stateRepo?.branch);
+  const goalStatePath2 = stringValue3(stateRepo?.goalStatePath);
+  const logPath = stringValue3(stateRepo?.logPath);
   if (repo && branch && goalStatePath2) links.goalState = githubBlobUrl(repo, branch, goalStatePath2);
   if (repo && branch && logPath) links.log = githubBlobUrl(repo, branch, logPath);
   return Object.keys(links).length > 0 ? links : void 0;
@@ -7554,7 +7833,7 @@ function githubBlobUrl(repo, branch, filePath) {
   }
 }
 function routeStepForLog(step) {
-  return pruneUndefined({
+  return pruneUndefined2({
     evidence: step.evidence,
     stage: step.stage,
     capability: step.capability,
@@ -7569,14 +7848,14 @@ function readGithubEvent() {
   try {
     if (!fs25.existsSync(eventPath)) return null;
     const parsed = JSON.parse(fs25.readFileSync(eventPath, "utf-8"));
-    return recordValue2(parsed);
+    return recordValue3(parsed);
   } catch {
     return null;
   }
 }
 function addScalarChange(change, field, before, after) {
   if (before === after) return;
-  change[field] = pruneUndefined({ from: before, to: after });
+  change[field] = pruneUndefined2({ from: before, to: after });
 }
 function diffRecordKeys(before, after) {
   const beforeKeys = new Set(Object.keys(before));
@@ -7594,7 +7873,7 @@ function diffStringArrays(before, after) {
     removed: before.filter((item) => !afterSet.has(item)).sort()
   };
 }
-function recordValue2(value) {
+function recordValue3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function stringArrayValue(value) {
@@ -7610,7 +7889,7 @@ function pickRecord(input, keys) {
   }
   return out;
 }
-function pruneUndefined(input) {
+function pruneUndefined2(input) {
   for (const key of Object.keys(input)) {
     if (input[key] === void 0) delete input[key];
   }
@@ -7620,7 +7899,7 @@ function truncateString(value, max) {
   if (!value) return void 0;
   return value.length > max ? `${value.slice(0, max)}...` : value;
 }
-function stringValue2(value) {
+function stringValue3(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
 function safePathSegment(value) {
@@ -7632,6 +7911,7 @@ var init_runLog = __esm({
   "src/goal/runLog.ts"() {
     "use strict";
     init_stateRepo();
+    init_runIndex();
     init_state2();
     LOGS_KEY = "__goalRunLogs";
     LOG_RUN_KEY = "__goalRunLogRunId";
@@ -8824,7 +9104,7 @@ var init_goalCapabilityScheduling = __esm({
 
 // src/scripts/advanceManagedGoal.ts
 function stageManagedGoalDecision(data, goalId, goal, goalState, decision, details) {
-  if (decision.kind === "dispatch") {
+  if (decision.kind === "dispatch" || decision.kind === "dispatchWorkflow") {
     stageGoalRunLogEvent(data, goalId, {
       source: "goal-manager",
       event: "goal.tick.dispatch",
@@ -8833,14 +9113,23 @@ function stageManagedGoalDecision(data, goalId, goal, goalState, decision, detai
       stage: decision.stage,
       evidence: decision.evidence,
       status: decision.kind,
-      dispatch: {
+      dispatch: decision.kind === "dispatchWorkflow" ? {
+        workflow: decision.workflow,
+        cliArgs: decision.cliArgs
+      } : {
         capability: decision.capability,
         cliArgs: decision.cliArgs,
         ...decision.executable ? { executable: decision.executable } : {}
       },
       goal: details.goalSnapshot,
       inspection: details.inspection,
-      decision: {
+      decision: decision.kind === "dispatchWorkflow" ? {
+        kind: decision.kind,
+        evidence: decision.evidence,
+        stage: decision.stage,
+        workflow: decision.workflow,
+        cliArgs: decision.cliArgs
+      } : {
         kind: decision.kind,
         evidence: decision.evidence,
         stage: decision.stage,
@@ -8923,7 +9212,7 @@ function previousDispatchWasTargetInstance(managed, previousScheduleState) {
   return previous.targetId === targetId || previous.targetId.startsWith(`${targetId}-`);
 }
 function ensureIssueFactIfNeeded(goal, goalId, cwd) {
-  if (!routeNeedsIssueFact(goal)) return;
+  if (!routeNeedsIssueFact(goal) && !workflowNeedsIssueFact(goal)) return;
   const existing = normalizeIssueNumber(goal.facts.issue);
   if (existing !== null) {
     goal.facts.issue = existing;
@@ -8940,6 +9229,14 @@ function routeNeedsIssueFact(goal) {
     })
   );
 }
+function workflowNeedsIssueFact(goal) {
+  return Object.values(goal.workflowRef?.args ?? {}).some(isIssueFactReference);
+}
+function isIssueFactReference(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record2 = value;
+  return Object.keys(record2).length === 1 && record2.fact === "issue";
+}
 function normalizeIssueNumber(value) {
   if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
   if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
@@ -9202,6 +9499,16 @@ var init_advanceManagedGoal = __esm({
         ctx.output.reason = decision.kind === "done" ? "managed goal complete" : decision.reason;
         return;
       }
+      if (decision.kind === "dispatchWorkflow") {
+        ctx.output.nextDispatch = {
+          workflow: decision.workflow,
+          cliArgs: decision.cliArgs,
+          ...decision.saveReport === true ? { saveReport: true } : {},
+          resultTarget: { type: "goal", id: goal.id }
+        };
+        ctx.output.reason = `dispatch workflow ${decision.workflow} for ${decision.evidence}`;
+        return;
+      }
       ctx.output.nextDispatch = {
         capability: decision.capability,
         cliArgs: decision.cliArgs,
@@ -14180,7 +14487,7 @@ var init_keys = __esm({
 // src/stateRepoGithub.ts
 import * as fs38 from "fs";
 import * as path36 from "path";
-function recordValue3(value) {
+function recordValue4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function contentsUrl(owner, repo, filePath) {
@@ -14236,12 +14543,12 @@ async function loadGithubStateConfig(opts) {
       throw new Error(`kody.config.json is invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  const githubRaw = recordValue3(raw.github) ?? {};
+  const githubRaw = recordValue4(raw.github) ?? {};
   const github = {
     owner: typeof githubRaw.owner === "string" && githubRaw.owner.trim() ? githubRaw.owner.trim() : opts.owner,
     repo: typeof githubRaw.repo === "string" && githubRaw.repo.trim() ? githubRaw.repo.trim() : opts.repo
   };
-  const nestedState = recordValue3(raw.state) ?? {};
+  const nestedState = recordValue4(raw.state) ?? {};
   const repoRaw = typeof raw.stateRepo === "string" ? raw.stateRepo : nestedState.repo;
   const pathRaw = typeof raw.statePath === "string" ? raw.statePath : nestedState.path;
   const stateRepo = typeof repoRaw === "string" && repoRaw.trim().length > 0 ? repoRaw.trim() : `https://github.com/${github.owner}/kody-state`;
@@ -19040,8 +19347,10 @@ function jobReferenceBlock(profileName, profile, data) {
 }
 async function runExecutable(profileName, input) {
   const stageStartedAt = Date.now();
+  let finishRunIndex = null;
   emitEvent(input.cwd, { executable: profileName, kind: "stage_start" });
   const finishAndEnd = (out) => {
+    finishRunIndex?.(out);
     emitEvent(input.cwd, {
       executable: profileName,
       kind: "stage_end",
@@ -19126,6 +19435,41 @@ async function runExecutable(profileName, input) {
     data: { ...input.preloadedData ?? {} },
     output: { exitCode: 0 }
   };
+  ctx.data.jobModel = modelSpec;
+  ctx.data.jobModelProvider = model.provider;
+  ctx.data.jobModelName = model.model;
+  if (reasoningEffort) ctx.data.jobReasoningEffort = reasoningEffort;
+  const runIndexStartedAt = new Date(stageStartedAt).toISOString();
+  if (!input.skipConfig) {
+    upsertRunIndexRowBestEffort(
+      config,
+      input.cwd,
+      runIndexRowFromJobContext({
+        data: ctx.data,
+        profileName,
+        profile,
+        status: "running",
+        startedAt: runIndexStartedAt,
+        updatedAt: runIndexStartedAt
+      })
+    );
+    finishRunIndex = (out) => {
+      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      upsertRunIndexRowBestEffort(
+        config,
+        input.cwd,
+        runIndexRowFromJobContext({
+          data: ctx.data,
+          profileName,
+          profile,
+          status: statusFromExitCode(out.exitCode),
+          startedAt: runIndexStartedAt,
+          updatedAt: finishedAt,
+          reason: out.reason
+        })
+      );
+    };
+  }
   const taskTarget = args.issue ?? args.pr;
   const taskArtifacts = typeof taskTarget === "number" && Number.isFinite(taskTarget) ? (() => {
     const taskType = args.issue ? "issue" : "pr";
@@ -19820,6 +20164,7 @@ var init_executor = __esm({
     init_litellm();
     init_profile();
     init_registry();
+    init_runIndex();
     init_runtimePaths();
     init_scripts();
     init_stateWorkspace();
@@ -20095,6 +20440,10 @@ function shouldRunCapabilityWorkflow(job, workflow, capabilityIdentity, selected
 async function runCapabilityWorkflow(parent, workflow, capability, base) {
   let chainData = {
     ...base.preloadedData ?? {},
+    runSubjectType: "workflow",
+    runSubjectId: capability.slug,
+    runSubjectLabel: capability.title,
+    runSubjectWorkflow: capability.slug,
     workflowCapability: capability.slug,
     workflowTitle: capability.title,
     workflowStepCount: workflow.steps.length,
@@ -22655,6 +23004,10 @@ function emitSse(res, event) {
 
 `);
 }
+function openSseStream(res, chatId) {
+  writeSseHeaders(res);
+  emitSse(res, { type: "chat", chatId });
+}
 function envGithubToken() {
   return (process.env.KODY_TOKEN ?? process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN ?? process.env.GH_PAT ?? "").trim();
 }
@@ -22664,16 +23017,6 @@ function parseRepoSlug(repo) {
   if (!owner || !name) return null;
   return { owner, repo: name };
 }
-function streamStartupError(res, dir, chatId, err) {
-  const sinceFloor = getLastSeq(dir, chatId);
-  const emitToLog = beginTurn(dir, chatId);
-  emitToLog({
-    type: "error",
-    chatId,
-    error: err instanceof Error ? err.message : String(err)
-  });
-  streamToRes(res, dir, chatId, sinceFloor);
-}
 function translateChatEvent(event, chatId) {
   switch (event.event) {
     case "chat.message": {
@@ -22727,9 +23070,10 @@ function enqueue(chatId, fn) {
   );
   return next;
 }
-function streamToRes(res, dir, chatId, since) {
-  writeSseHeaders(res);
-  emitSse(res, { type: "chat", chatId });
+function streamToRes(res, dir, chatId, since, opts = {}) {
+  if (!opts.opened) {
+    openSseStream(res, chatId);
+  }
   let maxSent = since;
   const unsubscribe = subscribe(
     dir,
@@ -22773,7 +23117,17 @@ async function handleChatTurn(req, res, chatId, opts) {
   const storeRepoUrl = strField(body, "storeRepoUrl");
   const storeRef = strField(body, "storeRef");
   const allowCrossRepo = boolField(body, "allowCrossRepo");
+  const firstTurn = boolField(body, "firstTurn");
   const agentIdentity = agentIdentityField(body);
+  openSseStream(res, chatId);
+  if (repo) {
+    emitSse(res, {
+      type: "tool_use",
+      chatId,
+      name: "prepare_repo",
+      input: { repo }
+    });
+  }
   let agentCwd;
   try {
     agentCwd = await ensureRepoCwd({
@@ -22784,7 +23138,12 @@ async function handleChatTurn(req, res, chatId, opts) {
       cloneRepo: opts.cloneRepo
     });
   } catch (err) {
-    streamStartupError(res, opts.cwd, chatId, err);
+    emitSse(res, {
+      type: "error",
+      chatId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    res.end();
     return;
   }
   const stateToken = repoToken || envGithubToken();
@@ -22807,7 +23166,7 @@ async function handleChatTurn(req, res, chatId, opts) {
   }
   const sessionFile = sessionFilePath(agentCwd, chatId);
   const brainEventsFile = brainEventsFilePath(agentCwd, chatId);
-  if (stateConfig && stateToken) {
+  if (!firstTurn && stateConfig && stateToken) {
     try {
       await syncJsonlFileFromGithubState({
         config: stateConfig,
@@ -22900,7 +23259,7 @@ async function handleChatTurn(req, res, chatId, opts) {
       }
     }
   });
-  streamToRes(res, agentCwd, chatId, sinceFloor);
+  streamToRes(res, agentCwd, chatId, sinceFloor, { opened: true });
 }
 function buildServer(opts) {
   const runTurn = opts.runTurn ?? runChatTurn;

package/package.json

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