@kody-ade/kody-engine 0.4.285 → 0.4.287

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.285",
+      version: "0.4.287",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
       license: "MIT",
       type: "module",
@@ -443,7 +443,7 @@ var STATE_BRANCH;
 var init_stateBranch = __esm({
   "src/stateBranch.ts"() {
     "use strict";
-    STATE_BRANCH = "kody-state";
+    STATE_BRANCH = "main";
   }
 });
 
@@ -497,18 +497,33 @@ function normalizeStatePath(raw, field = "statePath") {
   }
   return parts.join("/");
 }
+function normalizeStateBranch(raw, field = "state.branch") {
+  const value = raw?.trim() || STATE_BRANCH;
+  if (!value) throw new Error(`kody.config.json: ${field} must not be empty`);
+  if (value.startsWith("/") || value.endsWith("/") || value.includes("\\") || value.includes("..") || value.includes("@{") || /[\x00-\x20\x7f~^:?*\[]/.test(value)) {
+    throw new Error(`kody.config.json: ${field} contains an invalid branch`);
+  }
+  for (const part of value.split("/")) {
+    if (!part || part === "." || part === ".." || part.startsWith(".") || part.endsWith(".lock")) {
+      throw new Error(`kody.config.json: ${field} contains an invalid branch`);
+    }
+  }
+  return value;
+}
 function resolveStateRepoConfig(config) {
   if (config.state?.repo && config.state?.path) {
     parseStateRepoSlug(config.state.repo);
     return {
       repo: config.state.repo,
-      path: normalizeStatePath(config.state.path)
+      path: normalizeStatePath(config.state.path),
+      branch: normalizeStateBranch(config.state.branch)
     };
   }
   if (config.github?.owner && config.github?.repo) {
     return {
       repo: `${config.github.owner}/kody-state`,
-      path: normalizeStatePath(config.github.repo)
+      path: normalizeStatePath(config.github.repo),
+      branch: normalizeStateBranch(void 0)
     };
   }
   throw new Error("stateRepo: config.state or config.github owner/repo is required");
@@ -516,7 +531,7 @@ function resolveStateRepoConfig(config) {
 function parseStateRepo(config) {
   const state = resolveStateRepoConfig(config);
   const parsed = parseStateRepoSlug(state.repo);
-  return { ...parsed, basePath: state.path };
+  return { ...parsed, basePath: state.path, branch: state.branch };
 }
 function stateRepoPath(config, filePath) {
   const state = resolveStateRepoConfig(config);
@@ -528,14 +543,15 @@ function apiPath(config, targetPath) {
   return `/repos/${parsed.owner}/${parsed.repo}/contents/${targetPath}`;
 }
 function branchApiPath(config, targetPath) {
-  return `${apiPath(config, targetPath)}?ref=${encodeURIComponent(STATE_BRANCH)}`;
+  const state = resolveStateRepoConfig(config);
+  return `${apiPath(config, targetPath)}?ref=${encodeURIComponent(state.branch)}`;
 }
 function ensureStateBranch(config, cwd) {
   const parsed = parseStateRepo(config);
-  const cacheKey3 = `${parsed.owner}/${parsed.repo}:${STATE_BRANCH}`;
+  const cacheKey3 = `${parsed.owner}/${parsed.repo}:${parsed.branch}`;
   if (ensuredStateBranches.has(cacheKey3)) return;
   try {
-    gh(["api", `/repos/${parsed.owner}/${parsed.repo}/git/ref/heads/${STATE_BRANCH}`], { cwd });
+    gh(["api", `/repos/${parsed.owner}/${parsed.repo}/git/ref/heads/${parsed.branch}`], { cwd });
     ensuredStateBranches.add(cacheKey3);
     return;
   } catch (err) {
@@ -550,7 +566,7 @@ function ensureStateBranch(config, cwd) {
   try {
     gh(["api", "--method", "POST", `/repos/${parsed.owner}/${parsed.repo}/git/refs`, "--input", "-"], {
       cwd,
-      input: JSON.stringify({ ref: `refs/heads/${STATE_BRANCH}`, sha })
+      input: JSON.stringify({ ref: `refs/heads/${parsed.branch}`, sha })
     });
   } catch (err) {
     if (!isAlreadyExists(err)) throw err;
@@ -590,7 +606,7 @@ function writeStateText(config, cwd, filePath, content, message, sha) {
   const payload = {
     message,
     content: Buffer.from(content, "utf-8").toString("base64"),
-    branch: STATE_BRANCH
+    branch: resolveStateRepoConfig(config).branch
   };
   if (sha) payload.sha = sha;
   gh(["api", "--method", "PUT", apiPath(config, targetPath), "--input", "-"], {
@@ -722,12 +738,14 @@ function parseStateConfig(raw, github) {
   const nested = recordValue(raw.state) ?? {};
   const repoRaw = typeof raw.stateRepo === "string" ? raw.stateRepo : nested.repo;
   const pathRaw = typeof raw.statePath === "string" ? raw.statePath : nested.path;
+  const branchRaw = typeof raw.stateBranch === "string" ? raw.stateBranch : nested.branch;
   const stateRepo = typeof repoRaw === "string" && repoRaw.trim().length > 0 ? repoRaw.trim() : `https://github.com/${String(github.owner)}/kody-state`;
   parseStateRepoSlug(stateRepo);
   const statePath = typeof pathRaw === "string" && pathRaw.trim().length > 0 ? pathRaw.trim() : String(github.repo);
   return {
     repo: stateRepo,
-    path: normalizeStatePath(statePath)
+    path: normalizeStatePath(statePath),
+    branch: typeof branchRaw === "string" && branchRaw.trim().length > 0 ? normalizeStateBranch(branchRaw) : normalizeStateBranch(void 0)
   };
 }
 function parseAccessConfig(raw) {
@@ -6878,6 +6896,7 @@ function stateRepoContext(config, goalId, logPath) {
     return {
       repo: state.repo,
       path: state.path,
+      branch: state.branch,
       goalStatePath: `${state.path}/${goalStateLogPath(goalId)}`,
       logPath: `${state.path}/${logPath}`
     };
@@ -6976,16 +6995,17 @@ function linkContext(stateRepo) {
   const server = process.env.GITHUB_SERVER_URL?.trim() || "https://github.com";
   if (runId && repository) links.workflowRun = `${server}/${repository}/actions/runs/${runId}`;
   const repo = stringValue(stateRepo?.repo);
+  const branch = stringValue(stateRepo?.branch);
   const goalStatePath2 = stringValue(stateRepo?.goalStatePath);
   const logPath = stringValue(stateRepo?.logPath);
-  if (repo && goalStatePath2) links.goalState = githubBlobUrl(repo, goalStatePath2);
-  if (repo && logPath) links.log = githubBlobUrl(repo, 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;
 }
-function githubBlobUrl(repo, filePath) {
+function githubBlobUrl(repo, branch, filePath) {
   try {
     const parsed = parseStateRepoSlug(repo);
-    return `https://github.com/${parsed.owner}/${parsed.repo}/blob/${STATE_BRANCH}/${filePath}`;
+    return `https://github.com/${parsed.owner}/${parsed.repo}/blob/${encodeURIComponent(branch)}/${filePath}`;
   } catch {
     return void 0;
   }
@@ -7068,7 +7088,6 @@ var LOGS_KEY, LOG_RUN_KEY, LOG_STARTED_KEY;
 var init_runLog = __esm({
   "src/goal/runLog.ts"() {
     "use strict";
-    init_stateBranch();
     init_stateRepo();
     init_state2();
     LOGS_KEY = "__goalRunLogs";
@@ -7270,12 +7289,10 @@ var init_stateStore = __esm({
 // src/goal/targetLoopResolution.ts
 import * as fs26 from "fs";
 import * as path24 from "path";
-function resolveGoalLoopTarget(config, cwd, loopGoalId, loopGoal, now) {
+function resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal) {
   const targetId = loopGoal.loopTarget?.id.trim() ?? "";
   assertSafeGoalId(targetId, "loop target");
-  if (!hasExplicitStateRepo(config)) {
-    return { targetId, templateId: targetId, reason: "literal target; state repo not configured" };
-  }
+  if (!hasExplicitStateRepo(config)) return null;
   const activeInstance = findActiveTargetInstance(config, cwd, loopGoalId, targetId);
   if (activeInstance) {
     return {
@@ -7288,6 +7305,17 @@ function resolveGoalLoopTarget(config, cwd, loopGoalId, loopGoal, now) {
   if (directTarget?.state === "active") {
     return { targetId, templateId: targetId, reason: "active target goal" };
   }
+  return null;
+}
+function resolveGoalLoopTarget(config, cwd, loopGoalId, loopGoal, now) {
+  const targetId = loopGoal.loopTarget?.id.trim() ?? "";
+  assertSafeGoalId(targetId, "loop target");
+  if (!hasExplicitStateRepo(config)) {
+    return { targetId, templateId: targetId, reason: "literal target; state repo not configured" };
+  }
+  const activeTarget = resolveActiveGoalLoopTarget(config, cwd, loopGoalId, loopGoal);
+  if (activeTarget) return activeTarget;
+  const directTarget = fetchGoalState(config, targetId, cwd);
   const template = loadGoalTemplate(cwd, targetId);
   if (!template) {
     if (directTarget) {
@@ -7961,7 +7989,9 @@ function planTargetLoopSchedule(opts) {
   }
   const preferred = opts.goal.preferredRunTime;
   if (preferred) {
-    const gate = preferredRunTimeGate(preferred, now, opts.previousScheduleState);
+    const gate = preferredRunTimeGate(preferred, now, opts.previousScheduleState, {
+      allowRepeatAfterCompletedTarget: opts.allowRepeatAfterCompletedTarget === true
+    });
     if (!gate.ok) return targetLoopDecision("idle", gate.reason, at);
   }
   const dispatchTargetId = target.type === "goal" && opts.resolvedGoalTargetId?.trim() ? opts.resolvedGoalTargetId.trim() : targetId;
@@ -8123,7 +8153,7 @@ function targetLoopDecision(kind, reason, at) {
     }
   };
 }
-function preferredRunTimeGate(preferred, now, previous) {
+function preferredRunTimeGate(preferred, now, previous, opts) {
   const current = zonedTimeParts(now, preferred.timezone);
   if (!current) return { ok: false, reason: `invalid preferred timezone: ${preferred.timezone}` };
   const preferredMinute = preferredTimeToMinute(preferred.time);
@@ -8135,7 +8165,7 @@ function preferredRunTimeGate(preferred, now, previous) {
   const lastDispatchAt = previous?.lastDecision.kind === "dispatch" ? previous.lastDecision.at : void 0;
   if (lastDispatchAt) {
     const last = zonedTimeParts(new Date(lastDispatchAt), preferred.timezone);
-    if (last?.date === current.date) {
+    if (last?.date === current.date && opts?.allowRepeatAfterCompletedTarget !== true) {
       return { ok: false, reason: `already dispatched today at preferred time ${preferred.time} ${preferred.timezone}` };
     }
   }
@@ -8269,6 +8299,14 @@ function readSimpleGoalTaskSummary(goalId, cwd) {
   const open = issues.filter((issue) => String(issue.state ?? "").toLowerCase() === "open").length;
   return { total, open };
 }
+function previousDispatchWasTargetInstance(managed, previousScheduleState) {
+  const targetId = managed.loopTarget?.id.trim();
+  const previous = previousScheduleState?.lastDecision;
+  if (!targetId || previous?.kind !== "dispatch" || !("targetType" in previous) || previous.targetType !== "goal") {
+    return false;
+  }
+  return previous.targetId === targetId || previous.targetId.startsWith(`${targetId}-`);
+}
 function ensureIssueFactIfNeeded(goal, goalId, cwd) {
   if (!routeNeedsIssueFact(goal)) return;
   const existing = normalizeIssueNumber(goal.facts.issue);
@@ -8401,7 +8439,14 @@ var init_advanceManagedGoal = __esm({
         const beforeSnapshot = goalRunLogSnapshot(goal.id, goal.state, managed);
         const previousScheduleState = goal.raw.extra.scheduleState && typeof goal.raw.extra.scheduleState === "object" ? goal.raw.extra.scheduleState : void 0;
         const now = goalLoopNow();
-        let decision2 = planTargetLoopSchedule({ goal: managed, previousScheduleState, now });
+        const activeTarget = isGoalTargetLoop(managed) ? resolveActiveGoalLoopTarget(ctx.config, ctx.cwd, goal.id, managed) : null;
+        const allowRepeatAfterCompletedTarget = isGoalTargetLoop(managed) && !activeTarget && previousDispatchWasTargetInstance(managed, previousScheduleState);
+        let decision2 = planTargetLoopSchedule({
+          goal: managed,
+          previousScheduleState,
+          now,
+          allowRepeatAfterCompletedTarget
+        });
         let targetResolution;
         if (decision2.kind === "dispatch" && decision2.dispatch && isGoalTargetLoop(managed)) {
           targetResolution = resolveGoalLoopTarget(ctx.config, ctx.cwd, goal.id, managed, now);
@@ -8409,7 +8454,8 @@ var init_advanceManagedGoal = __esm({
             goal: managed,
             previousScheduleState,
             now,
-            resolvedGoalTargetId: targetResolution.targetId
+            resolvedGoalTargetId: targetResolution.targetId,
+            allowRepeatAfterCompletedTarget
           });
         }
         restoreGoalIdFact();
@@ -17509,7 +17555,7 @@ function overlayDirectoryChildren(cwd, sourceDir, localDir) {
 function hydrateStateWorkspace(config, cwd) {
   if (process.env.VITEST && process.env[TEST_FETCH_ENV] !== "1") return;
   const parsed = parseStateRepo(config);
-  const hydrateKey = `${path41.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${STATE_BRANCH}`;
+  const hydrateKey = `${path41.resolve(cwd)}|${parsed.owner}/${parsed.repo}|${parsed.basePath}|${parsed.branch}`;
   if (hydratedWorkspaces.has(hydrateKey)) return;
   const snapshotRoot = fetchStateSnapshot(parsed);
   for (const mapping of DIR_MAPPINGS) {
@@ -17533,7 +17579,7 @@ function fetchStateSnapshot(parsed) {
       runGit3(["clone", "--no-checkout", "--filter=blob:none", url, cacheDir]);
     }
     runGit3(["-C", cacheDir, "remote", "set-url", "origin", url]);
-    runGit3(["-C", cacheDir, "fetch", "--depth=1", "origin", STATE_BRANCH]);
+    runGit3(["-C", cacheDir, "fetch", "--depth=1", "origin", parsed.branch]);
     runGit3(["-C", cacheDir, "sparse-checkout", "init", "--cone"]);
     runGit3(["-C", cacheDir, "sparse-checkout", "set", parsed.basePath]);
     runGit3(["-C", cacheDir, "checkout", "--force", "--detach", "FETCH_HEAD"]);
@@ -17541,7 +17587,7 @@ function fetchStateSnapshot(parsed) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new Error(
-      `stateWorkspace: failed to fetch ${parsed.owner}/${parsed.repo}:${parsed.basePath}@${STATE_BRANCH}: ${msg}`
+      `stateWorkspace: failed to fetch ${parsed.owner}/${parsed.repo}:${parsed.basePath}@${parsed.branch}: ${msg}`
     );
   }
   return path41.join(cacheDir, parsed.basePath);
@@ -17550,7 +17596,7 @@ function cacheRoot2() {
   return process.env[CACHE_ENV2]?.trim() || path41.join(os7.homedir(), ".cache", "kody", "state-repo");
 }
 function cacheKey2(parsed) {
-  return crypto3.createHash("sha256").update(`${parsed.owner}/${parsed.repo}#${STATE_BRANCH}#${parsed.basePath}`).digest("hex").slice(0, 24);
+  return crypto3.createHash("sha256").update(`${parsed.owner}/${parsed.repo}#${parsed.branch}#${parsed.basePath}`).digest("hex").slice(0, 24);
 }
 function runGit3(args) {
   try {
@@ -17585,7 +17631,6 @@ var DIR_MAPPINGS, FILE_MAPPINGS, CACHE_ENV2, TEST_FETCH_ENV, hydratedWorkspaces;
 var init_stateWorkspace = __esm({
   "src/stateWorkspace.ts"() {
     "use strict";
-    init_stateBranch();
     init_stateRepo();
     DIR_MAPPINGS = [
       { stateDir: "executables", localDir: path41.join(".kody", "executables") },

package/package.json

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