cairn-ai 0.2.9 → 0.4.0

package/scripts/cairn-goal-state-validation.mjs

@@ -1,6 +1,7 @@
 import { normalizeVerificationArgv } from "./cairn-goal-evidence.mjs";
 
-export const GOAL_STATE_VERSION = 2;
+export const GOAL_STATE_VERSION = 3;
+export const MAX_ACTIVE_TASKS = 4;
 export const GOAL_STATUSES = new Set(["active", "paused", "blocked", "cancelled", "completed"]);
 export const TASK_STATUSES = new Set(["pending", "active", "blocked", "completed"]);
 export const PLAN_ID_MAX_LENGTH = 128;
@@ -20,6 +21,10 @@ export const defaultTaskEvidence = ["moduleAcceptance", "surfaceIntegration"];
 export const defaultGoalEvidence = ["finalReview"];
 
 const evidencePolicies = new Set(["declared", "tool-bound"]);
+export const TASK_ROUTES = new Set(["light", "heavy"]);
+export const CONCRETE_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+export const TASK_EFFORTS = new Set([...CONCRETE_EFFORTS, "inherited"]);
+export const EFFORT_SOURCES = new Set(["host-option", "inherited", "not-applied"]);
 
 export function validateState(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Cairn goal state must be an object");
@@ -43,7 +48,6 @@ export function validateState(value) {
   if (!Array.isArray(value.tasks) || value.tasks.length === 0) throw new Error("Cairn goal state must contain tasks");
   if (!Array.isArray(value.receipts)) throw new Error("Cairn goal state evidence records (receipts) must be an array");
   const ids = new Set();
-  let activeTasks = 0;
   for (const task of value.tasks) {
     if (!task || typeof task !== "object") throw new Error("Each task must be an object");
     const taskId = boundedRequiredText(task.id, "task.id", TASK_ID_MAX_LENGTH);
@@ -52,15 +56,22 @@ export function validateState(value) {
     ids.add(task.id);
     requiredText(task.title, "task.title");
     validTaskStatus(task.status);
-    if (task.status === "active") activeTasks += 1;
+    if (!Array.isArray(task.dependsOn)) throw new Error(`task ${task.id} dependsOn must be an array`);
+    if (task.writeScope !== null && !Array.isArray(task.writeScope)) throw new Error(`task ${task.id} writeScope must be an array or null`);
     if (task.assignedAgentId !== null && task.assignedAgentId !== undefined) requiredText(task.assignedAgentId, "task.assignedAgentId");
     if (!Array.isArray(task.requiredEvidence) || task.requiredEvidence.length === 0) throw new Error(`task ${task.id} requiredEvidence must be a non-empty array`);
     task.requiredEvidence.forEach((kind, index) => requiredText(kind, `task ${task.id} requiredEvidence[${index}]`));
     if (task.blocker !== null && task.blocker !== undefined) requiredText(task.blocker, `task ${task.id} blocker`);
+    // Optional since v3 states predate them; absent means unrecorded.
+    if (task.route !== null && task.route !== undefined) validTaskRoute(task.route, `task ${task.id} route`);
+    assertEffortRecord(task.effort ?? null, task.effortSource ?? null, `task ${task.id}`);
+    if (task.effortWaiver !== null && task.effortWaiver !== undefined) requiredText(task.effortWaiver, `task ${task.id} effortWaiver`);
     validTimestamp(task.createdAt);
     validTimestamp(task.updatedAt);
   }
-  if (activeTasks > 1) throw new Error("Only one task may be active");
+  assertTaskGraph(value.tasks);
+  const active = value.tasks.filter((task) => task.status === "active");
+  for (const task of active) assertCanRunAlongside(task, active.filter((other) => other !== task));
   for (const receipt of value.receipts) validateReceipt(receipt, value);
   return value;
 }
@@ -86,7 +97,9 @@ function validateReceipt(receipt, state) {
   }
 }
 
-export function normalizeTask(task, index, defaultStatus) {
+// dependsOn omitted means "after the previous task in list order" so existing sequential plans keep their order;
+// an explicit [] means no dependency.
+export function normalizeTask(task, index, defaultStatus, previousTaskId = null) {
   const source = typeof task === "string" ? { title: task } : task;
   if (!source || typeof source !== "object") throw new Error(`tasks[${index}] must be a string or object`);
   const id = source.id === undefined ? `task-${index + 1}` : boundedRequiredText(source.id, `tasks[${index}].id`, TASK_ID_MAX_LENGTH);
@@ -97,20 +110,136 @@ export function normalizeTask(task, index, defaultStatus) {
     status: source.status === undefined ? defaultStatus : validTaskStatus(source.status),
     assignedAgentId: source.assignedAgentId === undefined || source.assignedAgentId === null ? null : requiredText(source.assignedAgentId, `tasks[${index}].assignedAgentId`),
     requiredEvidence: normalizeCriteria(source.requiredEvidence ?? defaultTaskEvidence),
+    dependsOn: source.dependsOn === undefined
+      ? (previousTaskId === null ? [] : [previousTaskId])
+      : normalizeDependsOn(source.dependsOn, `tasks[${index}].dependsOn`),
+    writeScope: source.writeScope === undefined || source.writeScope === null
+      ? null
+      : normalizeWriteScope(source.writeScope, `tasks[${index}].writeScope`),
+    route: source.route === undefined || source.route === null ? null : validTaskRoute(source.route, `tasks[${index}].route`),
+    effort: null,
+    effortSource: null,
+    effortWaiver: null,
     blocker: null,
     createdAt: timestamp(),
     updatedAt: timestamp(),
   };
 }
 
+export function validTaskRoute(value, label = "route") {
+  if (!TASK_ROUTES.has(value)) throw new Error(`${label} must be one of: ${[...TASK_ROUTES].join(", ")}`);
+  return value;
+}
+
+// effort "inherited" pairs only with source "inherited"; source "host-option" needs a concrete level; a source
+// without an effort is only meaningful as "not-applied".
+export function assertEffortRecord(effort, source, label = "task") {
+  if (effort !== null && !TASK_EFFORTS.has(effort)) throw new Error(`${label} effort must be one of: ${[...TASK_EFFORTS].join(", ")}`);
+  if (source !== null && !EFFORT_SOURCES.has(source)) throw new Error(`${label} effortSource must be one of: ${[...EFFORT_SOURCES].join(", ")}`);
+  if (effort === "inherited" && source !== "inherited") throw new Error(`${label} effort inherited requires effortSource inherited`);
+  if (source === "host-option" && !CONCRETE_EFFORTS.has(effort)) throw new Error(`${label} effortSource host-option requires a concrete effort (${[...CONCRETE_EFFORTS].join(", ")})`);
+  if (source === "inherited" && effort === null) throw new Error(`${label} effortSource inherited requires an effort`);
+  if (effort !== null && source === null) throw new Error(`${label} effort requires an effortSource`);
+}
+
 export function migrateState(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || value.schemaVersion !== 1) return value;
-  return {
-    ...value,
-    schemaVersion: GOAL_STATE_VERSION,
-    goal: { ...value.goal, evidencePolicy: value.goal?.evidencePolicy ?? "tool-bound" },
-    receipts: Array.isArray(value.receipts) ? value.receipts.map((receipt) => ({ ...receipt, source: "declared" })) : value.receipts,
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  let state = value;
+  if (state.schemaVersion === 1) {
+    state = {
+      ...state,
+      schemaVersion: 2,
+      goal: { ...state.goal, evidencePolicy: state.goal?.evidencePolicy ?? "tool-bound" },
+      receipts: Array.isArray(state.receipts) ? state.receipts.map((receipt) => ({ ...receipt, source: "declared" })) : state.receipts,
+    };
+  }
+  if (state.schemaVersion === 2) {
+    // v2 tasks ran strictly in list order; make that order explicit as previous-task dependencies.
+    state = {
+      ...state,
+      schemaVersion: 3,
+      tasks: Array.isArray(state.tasks)
+        ? state.tasks.map((task, index) => ({
+          ...task,
+          dependsOn: index === 0 ? [] : [state.tasks[index - 1]?.id],
+          writeScope: null,
+        }))
+        : state.tasks,
+    };
+  }
+  return state;
+}
+
+export function normalizeDependsOn(value, label) {
+  if (!Array.isArray(value)) throw new Error(`${label} must be an array of task ids`);
+  return [...new Set(value.map((item, index) => boundedRequiredText(item, `${label}[${index}]`, TASK_ID_MAX_LENGTH)))];
+}
+
+export function normalizeWriteScope(value, label) {
+  if (!Array.isArray(value) || value.length === 0) throw new Error(`${label} writeScope must be a non-empty array of repository paths`);
+  return [...new Set(value.map((item, index) => {
+    const path = requiredText(item, `${label}[${index}]`).replace(/\\/g, "/").replace(/\/{2,}/g, "/")
+      .replace(/^(\.\/)+/, "").replace(/\/+$/, "");
+    if (/[*?[\]{}]/.test(path)) throw new Error(`${label} writeScope must list literal paths, not globs: ${item}`);
+    if (path === "" || path === "." || path.startsWith("/") || /^[a-zA-Z]:/.test(path) || path.split("/").includes("..")) {
+      throw new Error(`${label} writeScope must stay inside the repository: ${item}`);
+    }
+    return path;
+  }))];
+}
+
+// Segment-wise prefix match, case-insensitive so case-insensitive filesystems cannot hide an overlap.
+export function writeScopesOverlap(left, right) {
+  return left.some((a) => right.some((b) => pathContains(a, b) || pathContains(b, a)));
+}
+
+export function pathContains(scope, path) {
+  const outer = scope.toLowerCase();
+  const inner = path.toLowerCase();
+  return inner === outer || inner.startsWith(`${outer}/`);
+}
+
+export function assertTaskGraph(tasks) {
+  const byId = new Map();
+  for (const task of tasks) {
+    if (byId.has(task.id)) throw new Error(`Duplicate task id: ${task.id}`);
+    byId.set(task.id, task);
+  }
+  for (const task of tasks) {
+    for (const dependency of task.dependsOn) {
+      if (dependency === task.id) throw new Error(`Task ${task.id} cannot depend on itself`);
+      if (!byId.has(dependency)) throw new Error(`Task ${task.id} depends on unknown task: ${dependency}`);
+    }
+  }
+  const visiting = new Set();
+  const done = new Set();
+  const visit = (task, path) => {
+    if (done.has(task.id)) return;
+    if (visiting.has(task.id)) throw new Error(`Task dependency cycle: ${[...path, task.id].join(" -> ")}`);
+    visiting.add(task.id);
+    for (const dependency of task.dependsOn) visit(byId.get(dependency), [...path, task.id]);
+    visiting.delete(task.id);
+    done.add(task.id);
   };
+  for (const task of tasks) visit(task, []);
+}
+
+// Throws unless task may be active next to otherActive: dependencies completed, under the cap, and disjoint
+// writeScopes. A task without writeScope may only run alone.
+export function assertCanBeActive(tasks, task, otherActive) {
+  const waiting = task.dependsOn.filter((id) => tasks.find((item) => item.id === id)?.status !== "completed");
+  if (waiting.length > 0) throw new Error(`Task ${task.id} is waiting for: ${waiting.join(", ")}`);
+  assertCanRunAlongside(task, otherActive);
+}
+
+function assertCanRunAlongside(task, otherActive) {
+  if (otherActive.length === 0) return;
+  if (otherActive.length + 1 > MAX_ACTIVE_TASKS) throw new Error(`Only at most ${MAX_ACTIVE_TASKS} active tasks are allowed`);
+  if (task.writeScope === null) throw new Error(`Task ${task.id} without writeScope cannot run alongside active task ${otherActive[0].id}`);
+  for (const other of otherActive) {
+    if (other.writeScope === null) throw new Error(`Task ${task.id} cannot run alongside active task ${other.id} without writeScope`);
+    if (writeScopesOverlap(task.writeScope, other.writeScope)) throw new Error(`Task ${task.id} writeScope overlaps active task ${other.id}`);
+  }
 }
 
 export function requiredText(value, label) {
@@ -145,7 +274,7 @@ export function validTaskStatus(value) {
 }
 
 export function validReceiptScope(value) {
-  if (value !== "task" && value !== "goal") throw new Error(`Invalid evidence scope: ${value}`);
+  if (value !== "task" && value !== "goal") throw new Error(`Invalid evidence scope: ${value} (allowed: task, goal)`);
   return value;
 }
 

package/scripts/cairn-goal-state.mjs

@@ -18,12 +18,24 @@ export async function readGoalState({ root = process.cwd() } = {}) {
 }
 
 export function stopGuardPath(root = process.cwd()) {
-  return join(goalStateDirectory(root), "stop-guard.json");
+  return hookGuardPath(root, "stop");
+}
+
+export function hookGuardPath(root = process.cwd(), name) {
+  return join(goalStateDirectory(root), `${name}-guard.json`);
 }
 
 export async function readStopGuard(root = process.cwd()) {
+  return readHookGuard(root, "stop");
+}
+
+export async function writeStopGuard(root = process.cwd(), value) {
+  return writeHookGuard(root, "stop", value);
+}
+
+export async function readHookGuard(root = process.cwd(), name) {
   try {
-    const path = stopGuardPath(root);
+    const path = hookGuardPath(root, name);
     await assertNoSymlinkComponents(cairnHome(), path);
     const value = JSON.parse(await readFile(path, "utf8"));
     return value && typeof value === "object" ? value : null;
@@ -32,11 +44,11 @@ export async function readStopGuard(root = process.cwd()) {
   }
 }
 
-export async function writeStopGuard(root = process.cwd(), value) {
+export async function writeHookGuard(root = process.cwd(), name, value) {
   try {
-    await safeWriteFile(cairnHome(), stopGuardPath(root), `${JSON.stringify(value)}\n`, "utf8");
+    await safeWriteFile(cairnHome(), hookGuardPath(root, name), `${JSON.stringify(value)}\n`, "utf8");
   } catch {
-    // The guard only prevents no-progress continuation loops; failing to persist it must not break the stop hook.
+    // Guards only deduplicate hook output; failing to persist one must not break the hook.
   }
 }
 

package/scripts/cairn-goal.mjs

@@ -3,8 +3,9 @@ import { realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { runGoalCli } from "./cairn-goal-cli.mjs";
 import { assignTask, claimGoal, replanGoal, setTaskStatus, startGoal, transitionGoal } from "./cairn-goal-operations.mjs";
-import { recordReceipt, verifyAndRecord } from "./cairn-goal-operations-evidence.mjs";
+import { finishGoal, goalStats, recordReceipt, verifyAndRecord } from "./cairn-goal-operations-evidence.mjs";
 import { readGoalState } from "./cairn-goal-state.mjs";
+import { readyTasks } from "./cairn-goal-operations-mutations.mjs";
 import { defaultGoalEvidence } from "./cairn-goal-state-validation.mjs";
 
 export { workspaceFingerprint } from "./cairn-goal-evidence.mjs";
@@ -20,17 +21,22 @@ export {
 } from "./cairn-goal-state-validation.mjs";
 export { goalStatePath, readGoalState, writeGoalState } from "./cairn-goal-state.mjs";
 export { assignTask, claimGoal, reconcileWorktreeState, replanGoal, setTaskStatus, startGoal, transitionGoal } from "./cairn-goal-operations.mjs";
-export { recordReceipt, verifyAndRecord } from "./cairn-goal-operations-evidence.mjs";
+export { finishGoal, goalStats, recordReceipt, verifyAndRecord } from "./cairn-goal-operations-evidence.mjs";
 export { currentTask, evaluateStop, isGoalOwnedBySession } from "./cairn-goal-policy.mjs";
+export { readyTasks } from "./cairn-goal-operations-mutations.mjs";
 
-export async function handleGoalCli(args = process.argv.slice(2), { stdout = console.log } = {}) {
+export async function handleGoalCli(args = process.argv.slice(2), { stdout = console.log, stderr = console.error } = {}) {
   return runGoalCli(args, {
     stdout,
+    stderr,
     defaultGoalEvidence,
     operations: {
       assignTask,
       claimGoal,
+      finishGoal,
+      goalStats,
       readGoalState,
+      readyTasks,
       recordReceipt,
       replanGoal,
       setTaskStatus,

package/scripts/cairn-state-context.mjs

@@ -3,6 +3,7 @@ const contextLimits = {
   roadmapTaskId: 24,
   taskTitle: 40,
   roadmapWindow: 3,
+  parallelTitle: 16,
 };
 
 export function prependContext(result, notice) {
@@ -21,6 +22,8 @@ export function prependContext(result, notice) {
   };
 }
 
+import { currentTask } from "./cairn-goal-policy.mjs";
+
 export function contextResult({ ko, state, event }) {
   const base = kernelBase(ko);
   const idlePolicy = event === "user-prompt-submit"
@@ -37,9 +40,7 @@ export function contextResult({ ko, state, event }) {
     return interruptedContextResult(event, ko, state);
   }
   if (!state || state.goal.status !== "active") return contextHookResult({ event, message: `${base}${idlePolicy}${failClosed}` });
-  const task = state.tasks.find((item) => item.status === "active")
-    ?? state.tasks.find((item) => item.status === "pending")
-    ?? state.tasks.find((item) => item.status === "blocked");
+  const task = currentTask(state);
   const planId = state.goal.planId;
   const phase = task ? "cairn-work" : "cairn-review";
   const activeHeader = ko
@@ -69,7 +70,15 @@ export function contextResult({ ko, state, event }) {
         ? `곁가지 질문·조향 뒤 ${taskId}를 재개하고 남은 task를 최종 검토까지 진행하세요(일시정지·중단·전환 요청 제외).`
         : `After a side question or steer, resume ${taskId}, then advance remaining tasks to final review unless asked to pause, stop, or switch.`))
     : "";
-  return contextHookResult({ event, message: [activeHeader, taskRoadmap(ko, state), continuation, resume].filter(Boolean).join("\n") });
+  return contextHookResult({ event, message: [activeHeader, taskRoadmap(ko, state), continuation, parallelLine(ko, state), resume].filter(Boolean).join("\n") });
+}
+
+// Only when several tasks run at once: their ids and clipped titles, never the dependency graph.
+function parallelLine(ko, state) {
+  const active = state.tasks.filter((task) => task.status === "active");
+  if (active.length < 2) return "";
+  const list = active.map((task) => `${clipText(task.id, contextLimits.roadmapTaskId)} (${clipText(task.title, contextLimits.parallelTitle)})`).join(", ");
+  return `${ko ? "병렬 active" : "Parallel active"}: ${list}`;
 }
 
 function kernelBase(ko) {

package/scripts/cairn-state-init.mjs

@@ -66,7 +66,7 @@ This file is a short index of active and completed work plans.
 - Run complexity triage before applying agent, plugin, or delegated workflow guidance.
 - Record the selected Light Path or Heavy Path and the checked Heavy Path signals in \`docs/plan/<topic>.md\`.
 - Record request, planning, and code checkpoints. When the route changes before editing, synchronize the plan artifact, repository goal task roadmap through \`goal replan\`, and native UI plan. After editing starts, a new Heavy Path signal promotes Light Path to Heavy Path; stop further edits, mark affected evidence stale, synchronize all three roadmaps, and repeat the code checkpoint.
-- Keep models inherited. Record requested/effective reasoning effort per task: Light planning/implementation/verification=\`medium\`; Heavy planning/review/implementation=\`high\`; final verification/review=\`xhigh\`. A route change also synchronizes the reasoning effort profile, preserving completed profiles and recalculating incomplete profiles. Unsupported host/value means effective=\`inherited\` with no model/global config change.
+- Choose each task's model by nature (fast/balanced/stronger/strongest) and record requested/effective model and reasoning effort per task: Light planning/implementation/verification=\`medium\`; Heavy planning/review/implementation=\`high\`; final verification/review=\`xhigh\`. A route change also synchronizes the reasoning effort profile, preserving completed profiles and recalculating incomplete profiles. Every new task/worker dispatch MUST pass the requested effort through the host option (Claude Code: Agent \`effort\`, never fork) and the chosen model the same way (Agent \`model\`); Effective is the passed value, \`not-applied: <reason>\` when not passed, \`inherited\` only when the host has no option. Never change global/user config.
 - Split implementation into small module tasks.
 - Detect repository stack and required LSP/check tools before implementation.
 - Record missing required tools and suggested commands. Run only pinned, supported installation steps after explicit user approval.
@@ -100,7 +100,7 @@ const planTemplateKo = `# PLAN
 - 에이전트, 플러그인, 위임 워크플로 지침을 적용하기 전에 복잡도 트리아지를 실행합니다.
 - 선택한 Light Path 또는 Heavy Path와 확인한 Heavy Path 신호를 \`docs/plan/<topic>.md\`에 기록합니다.
 - 요청, 계획, 코드 체크포인트를 기록합니다. 편집 전에 경로가 바뀌면 plan artifact, 저장소 goal task roadmap, native UI plan을 동기화합니다. 편집 뒤 새 Heavy Path 신호가 나오면 추가 편집을 중단하고 관련 증거를 stale로 표시한 뒤 세 roadmap과 코드 체크포인트를 다시 맞춥니다.
-- 모델은 상속하고 task별 requested/effective reasoning effort를 기록합니다. Light 계획/구현/검증은 \`medium\`, Heavy 계획/검토/구현은 \`high\`, 최종 검증/검토는 \`xhigh\`입니다. 경로 변경 시 reasoning effort profile도 동기화하고 완료 profile은 보존하며 미완료 profile은 재계산합니다. 미지원 host/value는 model/global config 변경 없이 effective=\`inherited\`입니다.
+- task 성격에 따라 task별 모델(fast/balanced/stronger/strongest)을 정하고 requested/effective model과 reasoning effort를 기록합니다. Light 계획/구현/검증은 \`medium\`, Heavy 계획/검토/구현은 \`high\`, 최종 검증/검토는 \`xhigh\`입니다. 경로 변경 시 reasoning effort profile도 동기화하고 완료 profile은 보존하며 미완료 profile은 재계산합니다. 모든 새 task/worker dispatch는 정한 모델과 요청 effort를 host option으로 반드시 전달합니다(Claude Code: Agent \`model\`/\`effort\`, fork 금지). Effective는 전달한 값, 전달하지 못하면 \`not-applied: <사유>\`, host에 option이 없을 때만 \`inherited\`이며 전역/사용자 config는 바꾸지 않습니다.
 - 구현은 작은 모듈 작업으로 나눕니다.
 - 구현 전에 저장소 스택과 필요한 LSP/check 도구를 감지합니다.
 - 필요한 도구가 없으면 누락 상태와 제안 명령을 기록합니다. 명시적 사용자 승인 뒤에만 고정된 지원 설치 단계를 실행합니다.

package/scripts/cairn-state.mjs

@@ -5,7 +5,7 @@ import { contextResult, foreignSessionContextResult, prependContext } from "./ca
 import { continuationReason, stopAllowedMessage, stopHookOutput } from "./cairn-state-hook.mjs";
 import { initializeProject } from "./cairn-state-init.mjs";
 import { evaluateStop, isGoalOwnedBySession, reconcileWorktreeState } from "./cairn-goal.mjs";
-import { readStopGuard, writeStopGuard } from "./cairn-goal-state.mjs";
+import { readHookGuard, readStopGuard, writeHookGuard, writeStopGuard } from "./cairn-goal-state.mjs";
 import { resolveRepoRoot } from "./cairn-paths.mjs";
 
 const recoverableGoalStatuses = new Set(["active", "paused", "blocked"]);
@@ -52,7 +52,10 @@ export async function runStateResult(event = "manual", {
     if (recoverableGoalStatuses.has(state?.goal?.status) && !isGoalOwnedBySession(state, payload?.session_id)) {
       return foreignSessionContextResult({ ko, event, sessionId: payload?.session_id, root: resolvedRoot });
     }
-    const result = contextResult({ ko, state, event });
+    const context = contextResult({ ko, state, event });
+    // SessionStart (also after compaction) carries a literal CLI prefix so agents do not rebuild or store it in a
+    // shell variable, which does not survive between tool calls.
+    const result = event === "session-start" ? appendContext(context, cliPrefixLine()) : context;
     if (!reconciled.removed) return result;
     const notice = ko
       ? "Cairn worktree 점검: 현재 worktree에 속하지 않는 stale Cairn 상태를 제거했습니다."
@@ -67,6 +70,19 @@ export async function runStateResult(event = "manual", {
     if (state?.goal?.status !== "active" || !isGoalOwnedBySession(state, payload?.session_id)) {
       return { status: 0, message: "", hookOutput: {} };
     }
+    // Remind once per goal, task, and session; repeating it after every edit only grows the cached prefix.
+    const reminderKey = {
+      goalId: state.goal.id,
+      taskId: state.tasks.find((task) => task.status === "active")?.id ?? null,
+      sessionId: payload?.session_id ?? null,
+    };
+    const previousReminder = await readHookGuard(resolvedRoot, "reminder");
+    if (previousReminder?.goalId === reminderKey.goalId
+      && previousReminder?.taskId === reminderKey.taskId
+      && previousReminder?.sessionId === reminderKey.sessionId) {
+      return { status: 0, message: "", hookOutput: {} };
+    }
+    await writeHookGuard(resolvedRoot, "reminder", reminderKey);
     const message = ko
       ? "Cairn 점검: 외부 상태 변경에는 dry-run/check 증거 기록이 필요합니다. 활성 목표가 있다면 현재 task에 성공 증거를 기록하세요."
       : "Cairn check: external-state changes need dry-run/check evidence. When a goal is active, record successful evidence for its current task.";
@@ -106,14 +122,40 @@ export async function runStateResult(event = "manual", {
 
 async function recordStopProgress(root, state, event, payload) {
   const scope = event === "subagent-stop" ? `subagent:${payload?.agent_id ?? ""}` : "turn";
+  // Parallel workers share this guard: keep one entry per scope, and measure a worker's progress by its own task
+  // so sibling writes (which bump the goal revision) do not look like progress.
+  const assigned = event === "subagent-stop"
+    ? state.tasks.find((task) => task.status === "active" && task.assignedAgentId === payload?.agent_id)
+    : null;
+  const marker = assigned ? `${assigned.id}:${assigned.status}:${assigned.updatedAt}` : state.revision;
   const previous = await readStopGuard(root);
-  const progressed = previous?.goalId !== state.goal.id
-    || previous?.scope !== scope
-    || previous?.revision !== state.revision;
-  if (progressed) await writeStopGuard(root, { goalId: state.goal.id, scope, revision: state.revision });
+  const scopes = previous?.goalId === state.goal.id && previous?.scopes && typeof previous.scopes === "object" ? previous.scopes : {};
+  const progressed = scopes[scope] !== marker;
+  if (progressed) {
+    const entries = Object.entries({ ...scopes, [scope]: marker }).slice(-16);
+    await writeStopGuard(root, { goalId: state.goal.id, scopes: Object.fromEntries(entries) });
+  }
   return progressed;
 }
 
+// Only the CLI path: goal commands resolve the repository root themselves, and a second absolute path would let
+// long install or checkout paths push the SessionStart capsule past its budget.
+function cliPrefixLine() {
+  const cli = fileURLToPath(new URL("./cairn.mjs", import.meta.url));
+  return `Cairn CLI: node ${JSON.stringify(cli)} goal <command>`;
+}
+
+function appendContext(result, line) {
+  const specific = result.hookOutput?.hookSpecificOutput;
+  return {
+    ...result,
+    message: `${result.message}\n${line}`,
+    hookOutput: specific
+      ? { ...result.hookOutput, hookSpecificOutput: { ...specific, additionalContext: `${specific.additionalContext}\n${line}` } }
+      : result.hookOutput,
+  };
+}
+
 function hookFailureResult(event, error) {
   const detail = String(error?.message ?? error).split("\n")[0].slice(0, 300);
   const message = `Cairn ${event} hook could not read goal state: ${detail}. Run cairn goal status to inspect it; do not treat an active goal as finished.`;

package/scripts/cairn.mjs

@@ -84,7 +84,7 @@ const workExecutionPolicy = "The user-called/main agent orchestrates, while work
 const tokenEfficientWorkPolicy = "Use a test contract for requirements, invariants, boundaries, and failure modes before the minimum implementation. The tool exit code is authoritative. Run goal verify -- <argv> and expand only failures. Inspect package lifecycle scripts: content-producing or unknown scripts must never use --ignore-scripts; only absent or proven content-neutral scripts may use it while prior full-check evidence remains fresh.";
 const stagedTriagePolicy = "Use request, planning, and code checkpoints. Before the first edit, evidence may change either route; synchronize the plan artifact, repository goal task roadmap through goal replan, and native UI plan. After editing starts, a new Heavy Path signal promotes Light Path to Heavy Path: stop further edits, mark affected evidence stale, synchronize all three roadmaps, and repeat the code checkpoint.";
 const stagedTriagePolicyKo = "요청, 계획, 코드 체크포인트를 사용합니다. 첫 편집 전에는 증거에 따라 어느 경로로든 바꿀 수 있으며 plan artifact, 저장소 goal task roadmap, native UI plan을 동기화합니다. 편집 뒤 새 Heavy Path 신호가 나오면 Light Path를 Heavy Path로 승격하고 추가 편집을 중단하며 관련 증거를 stale로 표시한 뒤 세 roadmap과 코드 체크포인트를 다시 맞춥니다.";
-const reasoningEffortPolicy = "Inherit models; route reasoning effort by task: Light planning/implementation/verification=medium; Heavy planning/review/implementation=high; final verification/review=xhigh. Only new task dispatch may use a supported host option. Unsupported host/value means effective=inherited; never change model/global config.";
+const reasoningEffortPolicy = "Choose a model per task (fast/balanced/stronger/strongest) and pass it like effort; route reasoning effort by task: Light planning/implementation/verification=medium; Heavy planning/review/implementation=high; final verification/review=xhigh. Every new task/worker dispatch MUST pass the requested effort through the host option (Claude Code: Agent `effort`, never fork) and the chosen model the same way (Agent `model`); Effective is the passed value, `not-applied: <reason>` when not passed, `inherited` only when the host has no option. Never change global/user config.";
 const artifactLocalePolicy = "Write user-visible responses and generated or updated documentation, plans, and memory artifacts in the OS locale unless the user asks for another language.";
 const artifactLocalePolicyKo = "사용자가 다른 언어를 요청하지 않는 한, 사용자에게 보이는 응답과 생성 또는 갱신하는 문서, 계획, 메모리 산출물은 OS locale 언어로 작성합니다.";