@kody-ade/kody-engine 0.4.253 → 0.4.255

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.253",
+      version: "0.4.255",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative agentAction profiles.",
       license: "MIT",
       type: "module",
@@ -6179,6 +6179,88 @@ var init_state2 = __esm({
   }
 });
 
+// src/goal/runLog.ts
+function stageGoalRunLogEvent(data, goalId, event, at = nowIso()) {
+  const logs = goalRunLogs(data);
+  const existing = logs[goalId];
+  const path48 = existing?.path ?? goalRunLogPath(goalId, data);
+  logs[goalId] = {
+    path: path48,
+    events: [
+      ...existing?.events ?? [],
+      {
+        version: 1,
+        time: at,
+        goalId,
+        ...event
+      }
+    ]
+  };
+}
+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(event)).join("\n")}
+`;
+    appendStateLine(config, cwd, log2.path, lines, `chore(goal-logs): append ${goalId}`);
+    log2.events = [];
+  }
+}
+function goalRunLogPath(goalId, data) {
+  const startedAt = goalRunStartedAt(data);
+  const runId = goalRunId(data);
+  return `logs/goals/${safePathSegment(goalId)}/runs/${startedAt}-${runId}.jsonl`;
+}
+function goalRunLogs(data) {
+  const existing = data[LOGS_KEY];
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return existing;
+  }
+  const logs = {};
+  data[LOGS_KEY] = logs;
+  return logs;
+}
+function goalRunStartedAt(data) {
+  const existing = data[LOG_STARTED_KEY];
+  if (typeof existing === "string" && existing.length > 0) return existing;
+  const stamp = nowIso().replace(/[:.]/g, "-");
+  data[LOG_STARTED_KEY] = stamp;
+  return stamp;
+}
+function goalRunId(data) {
+  const existing = data[LOG_RUN_KEY];
+  if (typeof existing === "string" && existing.length > 0) return existing;
+  const raw = stringValue(data.jobId) ?? githubRunId() ?? `local-${process.pid}-${Date.now()}`;
+  const safe = safePathSegment(raw);
+  data[LOG_RUN_KEY] = safe;
+  return safe;
+}
+function githubRunId() {
+  const runId = process.env.GITHUB_RUN_ID?.trim();
+  if (!runId) return null;
+  const attempt = process.env.GITHUB_RUN_ATTEMPT?.trim();
+  return attempt ? `gh-${runId}-${attempt}` : `gh-${runId}`;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function safePathSegment(value) {
+  const safe = value.trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe || "unknown";
+}
+var LOGS_KEY, LOG_RUN_KEY, LOG_STARTED_KEY;
+var init_runLog = __esm({
+  "src/goal/runLog.ts"() {
+    "use strict";
+    init_stateRepo();
+    init_state2();
+    LOGS_KEY = "__goalRunLogs";
+    LOG_RUN_KEY = "__goalRunLogRunId";
+    LOG_STARTED_KEY = "__goalRunLogStartedAt";
+  }
+});
+
 // src/goal/typeDefinitions.ts
 function cloneRoute(route) {
   return route.map((step) => ({
@@ -6918,6 +7000,59 @@ var init_goalAgentResponsibilityScheduling = __esm({
 });
 
 // src/scripts/advanceManagedGoal.ts
+function stageManagedGoalDecision(data, goalId, goal, goalState, decision) {
+  if (decision.kind === "dispatch") {
+    stageGoalRunLogEvent(data, goalId, {
+      source: "goal-manager",
+      event: "goal.tick.dispatch",
+      goalType: goal.type,
+      goalState,
+      stage: decision.stage,
+      evidence: decision.evidence,
+      status: decision.kind,
+      dispatch: {
+        agentResponsibility: decision.agentResponsibility,
+        agentAction: decision.agentAction,
+        cliArgs: decision.cliArgs
+      }
+    });
+    return;
+  }
+  if (decision.kind === "done") {
+    stageGoalRunLogEvent(data, goalId, {
+      source: "goal-manager",
+      event: "goal.tick.done",
+      goalType: goal.type,
+      goalState: "done",
+      stage: "done",
+      status: decision.kind,
+      reason: "managed goal complete"
+    });
+    return;
+  }
+  if (decision.kind === "idle") {
+    stageGoalRunLogEvent(data, goalId, {
+      source: "goal-manager",
+      event: "goal.tick.idle",
+      goalType: goal.type,
+      goalState,
+      stage: goal.stage,
+      status: decision.kind,
+      reason: decision.reason
+    });
+    return;
+  }
+  stageGoalRunLogEvent(data, goalId, {
+    source: "goal-manager",
+    event: `goal.tick.${decision.kind}`,
+    goalType: goal.type,
+    goalState,
+    stage: decision.stage,
+    evidence: decision.evidence,
+    status: decision.kind,
+    reason: decision.reason
+  });
+}
 function readSimpleGoalTaskSummary(goalId, cwd) {
   const raw = gh(
     ["issue", "list", "--state", "all", "--label", `goal:${goalId}`, "--limit", "1000", "--json", "number,state"],
@@ -6984,6 +7119,7 @@ var init_advanceManagedGoal = __esm({
   "src/scripts/advanceManagedGoal.ts"() {
     "use strict";
     init_manager();
+    init_runLog();
     init_state2();
     init_typeDefinitions();
     init_issue();
@@ -7003,6 +7139,14 @@ var init_advanceManagedGoal = __esm({
         ctx.output.reason = "goal has no managed-goal contract; nothing to advance";
         return;
       }
+      stageGoalRunLogEvent(ctx.data, goal.id, {
+        source: "goal-manager",
+        event: "goal.tick.start",
+        goalType: managed.type,
+        goalState: goal.state,
+        stage: managed.stage,
+        facts: managed.facts
+      });
       const previousGoalIdFact = managed.facts.goalId;
       managed.facts.goalId = goal.id;
       const restoreGoalIdFact = () => {
@@ -7017,6 +7161,15 @@ var init_advanceManagedGoal = __esm({
         if (!managed.blockers.includes(reason)) managed.blockers.push(reason);
         restoreGoalIdFact();
         goal.raw = writeManagedGoalToState({ ...goal.raw, state: goal.state }, managed);
+        stageGoalRunLogEvent(ctx.data, goal.id, {
+          source: "goal-manager",
+          event: "goal.tick.blocked",
+          goalType: managed.type,
+          goalState: goal.state,
+          stage: managed.stage,
+          status: "blocked",
+          reason
+        });
         ctx.output.reason = reason;
         return;
       }
@@ -7034,6 +7187,17 @@ var init_advanceManagedGoal = __esm({
             cliArgs: decision2.dispatch.cliArgs
           };
         }
+        stageGoalRunLogEvent(ctx.data, goal.id, {
+          source: "goal-manager",
+          event: decision2.kind === "dispatch" ? "loop.tick.dispatch" : `loop.tick.${decision2.kind}`,
+          goalType: managed.type,
+          goalState: goal.state,
+          stage: managed.stage,
+          status: decision2.kind,
+          reason: decision2.reason,
+          target: decision2.dispatch?.cliArgs.goal && typeof decision2.dispatch.cliArgs.goal === "string" ? { type: "goal", id: decision2.dispatch.cliArgs.goal } : managed.loopTarget,
+          dispatch: decision2.dispatch
+        });
         ctx.output.reason = decision2.reason;
         return;
       }
@@ -7057,6 +7221,16 @@ var init_advanceManagedGoal = __esm({
             ...goal.raw.extra.saveReport === true ? { saveReport: true } : {}
           };
         }
+        stageGoalRunLogEvent(ctx.data, goal.id, {
+          source: "goal-manager",
+          event: decision2.kind === "dispatch" ? "loop.tick.dispatch" : `loop.tick.${decision2.kind}`,
+          goalType: managed.type,
+          goalState: goal.state,
+          stage: managed.stage,
+          status: decision2.kind,
+          reason: decision2.reason,
+          dispatch: decision2.dispatch
+        });
         ctx.output.reason = decision2.reason;
         return;
       }
@@ -7066,6 +7240,7 @@ var init_advanceManagedGoal = __esm({
       const decision = planManagedGoalTick(managed);
       restoreGoalIdFact();
       ctx.data.managedGoalDecision = decision;
+      stageManagedGoalDecision(ctx.data, goal.id, managed, goal.state, decision);
       if (decision.kind === "done") {
         goal.state = "done";
       }
@@ -7616,6 +7791,16 @@ var init_appendCompanyIntentDecision = __esm({
 });
 
 // src/scripts/applyAgentResponsibilityReports.ts
+function flushLogs(ctx) {
+  try {
+    flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
+  } catch (err) {
+    process.stderr.write(
+      `[kody agentResponsibility-report] goal log persist failed (${err instanceof Error ? err.message : String(err)})
+`
+    );
+  }
+}
 function collectReports(raw, agentResult) {
   const out = [];
   if (Array.isArray(raw)) {
@@ -7648,6 +7833,15 @@ function groupGoalReports(reports) {
   }
   return grouped;
 }
+function completeSatisfiedManagedGoal(state) {
+  if (state.state !== "active") return state;
+  const managed = managedGoalFromState(state);
+  if (!managed) return state;
+  if (!managed.destination.evidence.every((evidence) => managed.facts[evidence] === true)) return state;
+  const decision = planManagedGoalTick(managed);
+  if (decision.kind !== "done") return state;
+  return writeManagedGoalToState({ ...state, state: "done" }, managed);
+}
 function describeMessage(goalId, reports, results) {
   const pieces = [];
   if (reports && reports.length > 0) pieces.push(`report=${reports.length}`);
@@ -7660,6 +7854,8 @@ var init_applyAgentResponsibilityReports = __esm({
     "use strict";
     init_agent_responsibilityReport();
     init_agent_responsibilityResult();
+    init_manager();
+    init_runLog();
     init_state2();
     init_stateStore();
     applyAgentResponsibilityReports = async (ctx, _profile, agentResult) => {
@@ -7679,15 +7875,45 @@ var init_applyAgentResponsibilityReports = __esm({
         }
         let next = prior;
         for (const report of reportsByGoal.get(goalId) ?? []) {
+          stageGoalRunLogEvent(ctx.data, goalId, {
+            source: "goal-report",
+            event: "goal.evidence.reported",
+            goalState: prior.state,
+            evidenceValues: report.evidence,
+            facts: report.facts
+          });
           next = applyAgentResponsibilityReportToGoalState(next, report);
         }
         if (goalId === resultGoalId) {
           const evidence = typeof ctx.args.evidence === "string" && ctx.args.evidence.length > 0 ? ctx.args.evidence : void 0;
           for (const result of results) {
+            stageGoalRunLogEvent(ctx.data, goalId, {
+              source: "goal-report",
+              event: "goal.result.applied",
+              goalState: prior.state,
+              evidence,
+              status: result.status,
+              reason: result.summary,
+              facts: result.facts,
+              artifacts: result.artifacts
+            });
             next = applyAgentResponsibilityResultToObjectiveState(next, result, evidence);
           }
         }
-        if (serializeGoalState(next) === serializeGoalState(prior)) continue;
+        next = completeSatisfiedManagedGoal(next);
+        if (prior.state !== "done" && next.state === "done") {
+          stageGoalRunLogEvent(ctx.data, goalId, {
+            source: "goal-report",
+            event: "goal.completed",
+            goalState: "done",
+            status: "done",
+            reason: "destination evidence satisfied"
+          });
+        }
+        if (serializeGoalState(next) === serializeGoalState(prior)) {
+          flushLogs(ctx);
+          continue;
+        }
         putGoalState(
           ctx.config,
           goalId,
@@ -7695,6 +7921,7 @@ var init_applyAgentResponsibilityReports = __esm({
           describeMessage(goalId, reportsByGoal.get(goalId), results),
           ctx.cwd
         );
+        flushLogs(ctx);
       }
     };
   }
@@ -7966,6 +8193,16 @@ var init_commitAndPush = __esm({
 });
 
 // src/scripts/commitGoalState.ts
+function flushLogs2(ctx) {
+  try {
+    flushGoalRunLogEvents(ctx.config, ctx.cwd, ctx.data);
+  } catch (err) {
+    process.stderr.write(
+      `[goal-manager] goal log persist failed (${err instanceof Error ? err.message : String(err)})
+`
+    );
+  }
+}
 function describeCommitMessage(goal) {
   if (goal.state === "done") return `chore(goals): complete ${goal.id}`;
   return `chore(goals): update ${goal.id}`;
@@ -7974,13 +8211,23 @@ var commitGoalState;
 var init_commitGoalState = __esm({
   "src/scripts/commitGoalState.ts"() {
     "use strict";
+    init_runLog();
     init_stateStore();
     commitGoalState = async (ctx) => {
       const goal = ctx.data.goal;
-      if (!goal) return;
-      if (ctx.data.goalPersistChanged !== true) return;
+      if (!goal) {
+        flushLogs2(ctx);
+        return;
+      }
+      if (ctx.data.goalPersistChanged !== true) {
+        flushLogs2(ctx);
+        return;
+      }
       const updated = ctx.data.goalPersistState;
-      if (!updated) return;
+      if (!updated) {
+        flushLogs2(ctx);
+        return;
+      }
       try {
         putGoalState(ctx.config, goal.id, updated, describeCommitMessage(goal), ctx.cwd);
       } catch (err) {
@@ -7988,6 +8235,8 @@ var init_commitGoalState = __esm({
           `[goal-manager] commitGoalState: persist to state repo failed (${err instanceof Error ? err.message : String(err)}); will retry next tick
 `
         );
+      } finally {
+        flushLogs2(ctx);
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.253",
+  "version": "0.4.255",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative agentAction profiles.",
   "license": "MIT",
   "type": "module",
@@ -12,26 +12,6 @@
     "templates",
     "kody.config.schema.json"
   ],
-  "scripts": {
-    "kody:run": "tsx bin/kody.ts",
-    "serve": "tsx bin/kody.ts serve",
-    "serve:vscode": "tsx bin/kody.ts serve vscode",
-    "serve:claude": "tsx bin/kody.ts serve claude",
-    "build": "tsup && node scripts/copy-assets.cjs",
-    "check:modularity": "tsx scripts/check-script-modularity.ts",
-    "pretest": "pnpm check:modularity",
-    "test": "vitest run tests/unit tests/int --coverage",
-    "posttest": "tsx scripts/check-coverage-floor.ts",
-    "test:smoke": "vitest run tests/smoke --no-coverage",
-    "test:e2e": "vitest run tests/e2e --no-coverage",
-    "test:all": "vitest run tests --no-coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check",
-    "lint:fix": "biome check --write",
-    "format": "biome format --write",
-    "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner",
-    "prepublishOnly": "pnpm typecheck && vitest run tests/unit tests/int --no-coverage && pnpm build"
-  },
   "dependencies": {
     "@actions/cache": "^6.0.0",
     "@anthropic-ai/claude-agent-sdk": "0.2.119",
@@ -55,5 +35,24 @@
     "url": "git+https://github.com/aharonyaircohen/kody-engine.git"
   },
   "homepage": "https://github.com/aharonyaircohen/kody-engine",
-  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues"
-}
+  "bugs": "https://github.com/aharonyaircohen/kody-engine/issues",
+  "scripts": {
+    "kody:run": "tsx bin/kody.ts",
+    "serve": "tsx bin/kody.ts serve",
+    "serve:vscode": "tsx bin/kody.ts serve vscode",
+    "serve:claude": "tsx bin/kody.ts serve claude",
+    "build": "tsup && node scripts/copy-assets.cjs",
+    "check:modularity": "tsx scripts/check-script-modularity.ts",
+    "pretest": "pnpm check:modularity",
+    "test": "vitest run tests/unit tests/int --coverage",
+    "posttest": "tsx scripts/check-coverage-floor.ts",
+    "test:smoke": "vitest run tests/smoke --no-coverage",
+    "test:e2e": "vitest run tests/e2e --no-coverage",
+    "test:all": "vitest run tests --no-coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "format": "biome format --write",
+    "brain:publish": "docker buildx build --platform linux/amd64 -f runner/Dockerfile.brain -t ghcr.io/${KODY_BRAIN_GHCR_OWNER:-aharonyaircohen}/kody-brain:latest --push runner"
+  }
+}