@sabaiway/agent-workflow-kit 1.44.0 → 1.45.1

package/tools/procedures.mjs

@@ -36,6 +36,7 @@ import { plansInFlight, PLANS_REL } from './review-state.mjs';
 // (an import-split test pins it). CONFIG_REL is RE-EXPORTED so existing importers (procedures.test.mjs,
 // historically) keep their import site working.
 import { CONFIG_REL, fail, loadConfig, assertSlotRecipe } from './orchestration-config.mjs';
+import { AUTONOMY_REL, loadAutonomy, resolveAutonomy, isSparseSeedConfig } from './autonomy-config.mjs';
 export { CONFIG_REL };
 
 // ── argument + override parsing (usage errors → exit 2) ─────────────────────────────
@@ -224,7 +225,10 @@ const reviewLoopAdvice = (slots, activity) =>
 // (the review-state plan-in-flight detector): exactly ONE plan in flight → render it populated;
 // zero or several → the explicit `--plan <path>` placeholder + a one-line discovery caveat. The
 // suggested --out lives OUTSIDE the repo (/tmp) — grounding.mjs refuses a non-scratch destination.
-const GROUNDING_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'grounding.mjs');
+// Exported for the bridge-tier byte-parity pin (AD-044 Plan 4): the velocity tier seeds the
+// grounding rule in EXACTLY this rendered spelling — `node "${GROUNDING_TOOL}"` — so seeded and
+// rendered forms can never drift apart.
+export const GROUNDING_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'grounding.mjs');
 const GROUNDING_FACTS_OUT = '/tmp/review-facts.md';
 const groundingPreStepAdvice = (activity, slots, plans) => {
   if (!slots.some((s) => (s.backends ?? []).includes('agy-review'))) return [];
@@ -242,17 +246,42 @@ const groundingPreStepAdvice = (activity, slots, plans) => {
   // Path arguments are double-quoted — a skill dir or plan name with a space must stay copy-pasteable.
   const lines = [
     'Grounding pre-step (agy is dispatched — assemble the verified facts BEFORE the review; grounding.mjs slices verbatim, judgment additions stay yours):',
-    `  run:  node "${GROUNDING_TOOL}" --constraints ${planArg} --out ${GROUNDING_FACTS_OUT}`,
+    `  run:  node "${GROUNDING_TOOL}" --constraints --autonomy ${planArg} --out ${GROUNDING_FACTS_OUT}`,
     `  then: ${reviewForm} --facts @${GROUNDING_FACTS_OUT}`,
   ];
   if (plans.length === 0) {
-    lines.push(`  ↳ plan discovery: no plan in flight under ${PLANS_REL} — substitute the plan file you are reviewing against, or drop --plan for constraints-only facts.`);
+    lines.push(`  ↳ plan discovery: no plan in flight under ${PLANS_REL} — substitute the plan file you are reviewing against, or drop --plan for constraints+autonomy facts.`);
   } else if (plans.length > 1) {
     lines.push(`  ↳ plan discovery: ${plans.length} plans in flight under ${PLANS_REL} (${plans.join(', ')}) — populate --plan with the one under review.`);
   }
   return lines;
 };
 
+// The per-activity autonomy block (AD-044 Plan 4): the resolved level for THIS activity + what it
+// implies, rendered from resolveAutonomy — never retyped constants. Read at session start beside
+// the resolved recipes (the AGENTS.md autonomy pointer's read contract). A malformed policy
+// surfaces LOUDLY here (the session-start read is exactly where "malformed → STOP, never guess"
+// must be visible); an absent file states the computed-defaults origin honestly.
+const autonomyAdvice = (activity, facts) => {
+  if (facts == null) return [];
+  if (facts.error) return [`Autonomy (${AUTONOMY_REL}): MALFORMED — ${facts.error} — STOP and fix the policy file, never guess around it.`];
+  const level = facts.activities?.[activity]?.autonomy;
+  if (!level) return [];
+  const origin = facts.source === 'none'
+    ? `computed defaults — no ${AUTONOMY_REL}`
+    : facts.defaultsEquivalent
+      ? `computed defaults — ${AUTONOMY_REL} is the sparse defaults-equivalent seed`
+      : `from ${facts.source}`;
+  const redlines = Object.entries(facts.redlines).map(([k, v]) => `${k}=${v}`).join(', ');
+  const implies = level === 'sandbox'
+    ? 'the OS sandbox confines and auto-allows confined commands — work runs to the next checkpoint without per-command prompts'
+    : 'every non-allowlisted command prompts (the sandbox, where enabled, still confines)';
+  return [
+    `Autonomy for "${activity}" (${origin}): ${level} — ${implies}.`,
+    `  red-lines (always): ${redlines} — commit/push/publish keep their maintainer asks regardless of level.`,
+  ];
+};
+
 // The cost-lane advisory block (cost-tiered execution — orchestration.md §5 canon, paraphrased
 // at the point of use like reviewLoopAdvice paraphrases §9/§4). Rendered UNCONDITIONALLY for
 // every activity — the lanes route EVERY step, review-backed or not (unlike reviewLoopAdvice,
@@ -267,6 +296,7 @@ const costLanesAdvice = () => [
   '  • L2 subscription bridge (codex / agy) — reviews per the resolved recipe above, on frontier bridge models (quality-first).',
   '  • L3 frontier — judgment: plan/fold/synthesis, ADR/handover/changelog-entry wording, persuasive copy, go/no-go, real code.',
   '  • A step with no named guardrail does not move down a lane; red lines never move down (council review models · real code · memory/copy wording · the maintainer approval asks).',
+  '  • Sandbox lanes (under an OS sandbox): the L0 surfaces are sandbox-safe — gates/ledger/state/fold checks, git reads, plain no-network tests; the bridge wrappers are genuinely unsandboxed (network); npm-cache-touching commands are COMMAND-SHAPE dependent — first try the sandbox-safe shape (cache under $TMPDIR, offline/notifier off). Move ONLY the failing command out of the sandbox, never its class; BATCH consecutive unsandboxed calls.',
 ];
 
 // The verbatim per-backend DRIVING CONTRACT block (M-contract): the exact invocation descriptor(s),
@@ -297,7 +327,7 @@ const contractLines = ({ cmd, contract, settings }) => {
   return lines;
 };
 
-const formatHuman = ({ activity, section, slots, warnings, plans }) => {
+const formatHuman = ({ activity, section, slots, warnings, plans, autonomy }) => {
   const lines = [
     section,
     '',
@@ -309,6 +339,8 @@ const formatHuman = ({ activity, section, slots, warnings, plans }) => {
     if (s.reason) lines.push(`      ↳ ${s.reason}`);
     for (const c of s.contracts ?? []) lines.push(...contractLines(c));
   }
+  const autonomyBlock = autonomyAdvice(activity, autonomy);
+  if (autonomyBlock.length) lines.push('', ...autonomyBlock);
   const grounding = groundingPreStepAdvice(activity, slots, plans);
   if (grounding.length) lines.push('', ...grounding);
   const advice = reviewLoopAdvice(slots, activity);
@@ -321,7 +353,7 @@ const formatHuman = ({ activity, section, slots, warnings, plans }) => {
   return lines.join('\n');
 };
 
-const buildJson = ({ activity, section, slots, configSource, warnings, plans }) => ({
+const buildJson = ({ activity, section, slots, configSource, warnings, plans, autonomy }) => ({
   activity,
   section,
   slots: Object.fromEntries(
@@ -334,6 +366,8 @@ const buildJson = ({ activity, section, slots, configSource, warnings, plans })
   groundingPreStep: groundingPreStepAdvice(activity, slots, plans),
   // ADDITIVE (cost-tiered execution): the unconditional cost-lane advisory, structured.
   costLanes: costLanesAdvice(),
+  // ADDITIVE (AD-044 Plan 4): the per-activity autonomy block, structured (empty when unresolvable).
+  autonomy: autonomyAdvice(activity, autonomy),
   configSource,
   warnings,
 });
@@ -354,7 +388,8 @@ ${CONFIG_REL} + the read-only backend detector, and prints both. A per-run
 Read-only: never writes, never commits, never runs a subscription CLI.
 
 Exit codes: 0 success (an unsatisfiable override degrades loudly, still 0);
-            2 usage (unknown activity / bad --override); 1 config or engine error.`;
+            2 usage (unknown activity / bad --override); 1 config or engine error
+            (incl. a malformed ${AUTONOMY_REL} — the advisory still renders, the exit flips).`;
 
 // ── main ───────────────────────────────────────────────────────────────────────────
 
@@ -387,9 +422,27 @@ export const main = (argv, ctx = {}) => {
     const slots = resolveAllSlots({ activity, config, detection, overrides });
     const warnings = [...detectWarnings, ...collectWarnings(slots)];
     const plans = plansInFlight(cwd);
+    // The autonomy facts (AD-044 Plan 4): resolved levels + red-lines from the policy file. A
+    // malformed policy renders LOUDLY in the block AND flips the exit to 1 (config error) — the
+    // recipes and contracts still print, only the code changes.
+    const autonomy = (() => {
+      try {
+        const { config: autonomyConfig, source } = loadAutonomy(cwd, readFile, lstat);
+        const resolved = resolveAutonomy(autonomyConfig);
+        // Structural seed detection (shared predicate) — a declared-defaults policy reads as
+        // "from docs/ai/autonomy.json", never as the seed (codex, Segment B closing).
+        const defaultsEquivalent = source !== 'none' && isSparseSeedConfig(autonomyConfig);
+        return { source, defaultsEquivalent, ...resolved };
+      } catch (err) {
+        return { error: (err && err.message) || String(err) };
+      }
+    })();
     const stdout = json
-      ? JSON.stringify(buildJson({ activity, section, slots, configSource, warnings, plans }), null, 2)
-      : formatHuman({ activity, section, slots, warnings, plans });
+      ? JSON.stringify(buildJson({ activity, section, slots, configSource, warnings, plans, autonomy }), null, 2)
+      : formatHuman({ activity, section, slots, warnings, plans, autonomy });
+    if (autonomy?.error) {
+      return { code: 1, stdout, stderr: `procedures: malformed ${AUTONOMY_REL} — ${autonomy.error}` };
+    }
     return { code: 0, stdout, stderr: '' };
   } catch (err) {
     return { code: err.exitCode ?? 1, stdout: '', stderr: `procedures: ${err.message}` };

package/tools/recipes.mjs

@@ -14,6 +14,8 @@
 // orchestrator (the main agent) executes it via the bridge skills and always makes the single commit;
 // a backend is advisory or delegated, never autonomous. Dependency-free, Node >= 18.
 
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 // The host-level bridge-settings snapshot (fact-only, best-effort). READ-ONLY core only — never the
 // writer — so this read-only advisor never pulls in the atomic-write core.
@@ -296,7 +298,7 @@ export const resolveActivityRecipe = ({ config = {}, readiness = [], activity, s
 // DISPLAY_ALIASES — the ONE alias table the recommendation clause already uses; ordering is the
 // deterministic BACKEND_PRIORITY (codex before agy), independent of detection emission order.
 // Always exactly one line: no part may carry a newline (pinned by tests).
-export const composeStatusLine = (detection, recommendation, settings = null) => {
+export const composeStatusLine = (detection, recommendation, settings = null, autonomy = null) => {
   const backends = [...detection]
     .sort((a, b) => priorityIndex(a.name) - priorityIndex(b.name))
     .map((b) => `${DISPLAY_ALIASES[b.name] ?? b.name} ${b.readiness === READY ? '✓' : '✗'} ${b.readiness}`)
@@ -308,7 +310,71 @@ export const composeStatusLine = (detection, recommendation, settings = null) =>
   const oneLine = (s) => String(s).replace(/[\s]+/g, ' ').trim();
   const active = settings?.active ?? [];
   const suffix = active.length ? ` · settings: ${active.map((s) => `${oneLine(s.key)}=${oneLine(s.value)}`).join(' · ')}` : '';
-  return base + suffix;
+  // The autonomy segment (AD-044 Plan 4): rendered ONLY when the caller supplies the computed
+  // facts (composeAutonomyFacts) — an omitted param keeps the line byte-identical (the settings-
+  // suffix precedent). Fact-only: effective per-activity levels + the render-sync state; an absent
+  // policy says "computed defaults" honestly; a malformed policy surfaces LOUDLY, never omitted.
+  const autonomySegment = autonomy == null ? '' : ` · autonomy: ${oneLine(formatAutonomySegment(autonomy))}`;
+  return base + suffix + autonomySegment;
+};
+
+// The one-segment autonomy renderer behind composeStatusLine's 4th param.
+const formatAutonomySegment = (a) => {
+  if (a.error) return `MALFORMED policy — ${a.error}`;
+  const levels = Object.entries(a.activities ?? {}).map(([k, v]) => `${k}=${v.autonomy}`).join(', ');
+  const state = a.source === 'none'
+    ? 'computed defaults — no policy file; declare with /agent-workflow-kit set-autonomy'
+    : a.defaultsEquivalent
+      ? 'declared, defaults-equivalent — computed defaults apply; declare levels with /agent-workflow-kit set-autonomy'
+      : `declared; render ${a.renderState}`;
+  return `${levels} (${state})`;
+};
+
+// composeAutonomyFacts(cwd) → the fact object the status/active lines render (AD-044 Plan 4):
+// { source, redlines, activities, renderState } or { error }. Lazy imports — autonomy-config
+// statically imports THIS module (ACTIVITIES) and velocity-profile is heavy, so both load at call
+// time only (the loadConfig precedent). Never throws: a malformed policy becomes { error } so the
+// one-line surfaces render it loudly instead of dying.
+// The policy lives at the PROJECT root; the report-footer invokes the paste surfaces without
+// --cwd, so a subdirectory shell must still find it. Nearest-.git walk-up (dir or worktree file),
+// fs-only — this advisor stays spawn-free; no repo found → the cwd itself (fixture behavior).
+const projectTopOf = (cwd) => {
+  let dir = resolve(cwd);
+  for (;;) {
+    if (existsSync(join(dir, '.git'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return resolve(cwd);
+    dir = parent;
+  }
+};
+
+export const composeAutonomyFacts = async (cwd) => {
+  try {
+    const root = projectTopOf(cwd);
+    const { loadAutonomy, resolveAutonomy, isSparseSeedConfig } = await import('./autonomy-config.mjs');
+    const { config, source } = loadAutonomy(root);
+    const resolved = resolveAutonomy(config);
+    if (source === 'none') return { source, redlines: resolved.redlines, activities: resolved.activities, renderState: null };
+    // The STRUCTURAL seed (_README only) is a fresh-deployment NORMAL — treating it as "declared"
+    // would report "render DRIFT" on every fresh upgrade (codex, Segment B). An EXPLICIT policy
+    // declaring the default values is a real declaration — its render state IS computed
+    // (structural detection, codex Segment B closing).
+    if (isSparseSeedConfig(config)) {
+      return { source, defaultsEquivalent: true, redlines: resolved.redlines, activities: resolved.activities, renderState: null };
+    }
+    let renderState;
+    try {
+      const { checkAutonomyProfile } = await import('./velocity-profile.mjs');
+      renderState = checkAutonomyProfile({ cwd: root }).inSync
+        ? 'in sync'
+        : 'DRIFT — re-run the velocity --autonomy render';
+    } catch (err) {
+      renderState = `unchecked (${err?.message ?? err})`;
+    }
+    return { source, redlines: resolved.redlines, activities: resolved.activities, renderState };
+  } catch (err) {
+    return { error: err?.message ?? String(err) };
+  }
 };
 
 // ── the one-line ACTIVE-recipe line (the discovery line — configured, never recommended) ───────────
@@ -321,17 +387,21 @@ export const composeStatusLine = (detection, recommendation, settings = null) =>
 // session-start checklist + the handover "Active recipes:" slot paste it verbatim, so no agent composes
 // the configured-recipe facts by hand. `{ config, source }` is exactly what loadConfig returns (source
 // 'none' when no config file exists). Always exactly one line: no part may carry a newline (pinned).
-export const composeActiveRecipeLine = ({ config, source } = {}, detection) => {
+export const composeActiveRecipeLine = ({ config, source } = {}, detection, autonomy = null) => {
   const cells = [];
   for (const [activity, def] of Object.entries(ACTIVITIES)) {
+    // The per-activity autonomy level rides each cell when the caller supplies the facts (AD-044
+    // Plan 4) — an omitted param keeps the line byte-identical (the composeStatusLine precedent).
+    const level = autonomy?.activities?.[activity]?.autonomy;
+    const auto = level ? `; autonomy ${level}` : '';
     for (const slot of Object.keys(def.slots)) {
       const r = resolveActivityRecipe({ config: config ?? {}, readiness: detection, activity, slot });
       const { dispatch } = planRecipe(r.recipe, detection);
       const wrappers = dispatch.map((d) => wrapperCmdFor(d.backend, d.role)).filter(Boolean);
       const srcLabel = r.source === 'config' ? 'configured' : 'computed default';
       const head = r.degradedFrom
-        ? `${activity}.${slot} = ${r.degradedFrom} (${srcLabel}; degrades here to ${r.recipe} — ${r.reason})`
-        : `${activity}.${slot} = ${r.recipe} (${srcLabel})`;
+        ? `${activity}.${slot} = ${r.degradedFrom} (${srcLabel}; degrades here to ${r.recipe} — ${r.reason}${auto})`
+        : `${activity}.${slot} = ${r.recipe} (${srcLabel}${auto})`;
       const suffix =
         wrappers.length >= 2
           ? ` → every backend every round: ${wrappers.join(' + ')}`
@@ -343,14 +413,19 @@ export const composeActiveRecipeLine = ({ config, source } = {}, detection) => {
   }
   const rec = recommendRecipe(detection);
   const origin = source === 'none' || config == null ? 'no config file — computed defaults apply' : `from ${source}`;
-  return `active recipes (${origin}): ${cells.join(' · ')} — the configured recipes above are what runs; readiness-recommended here: ${rec.recipe} (informational)`;
+  // A MALFORMED policy must surface LOUDLY on this paste surface too — silently rendering cells
+  // without levels would hide the required STOP signal (codex R1, Segment B). One line always.
+  const malformed = autonomy?.error
+    ? ` · autonomy: MALFORMED policy — ${String(autonomy.error).replace(/[\s]+/g, ' ').trim()}`
+    : '';
+  return `active recipes (${origin}): ${cells.join(' · ')} — the configured recipes above are what runs; readiness-recommended here: ${rec.recipe} (informational)${malformed}`;
 };
 
 // ── report + CLI ─────────────────────────────────────────────────────────────────
 
 // The structured report behind `--json` — the recipes, the recommendation, a plan per recipe, and
 // (additive) the pasteable one-line backend status composed from the same detection.
-export const buildReport = (detection, settings = null) => {
+export const buildReport = (detection, settings = null, autonomy = null) => {
   const recommendation = recommendRecipe(detection);
   return {
     recipes: RECIPES.map(({ id, title, role, minBackends, degradesTo, summary }) => ({
@@ -363,7 +438,9 @@ export const buildReport = (detection, settings = null) => {
     })),
     recommendation,
     plans: RECIPES.map((r) => planRecipe(r.id, detection)),
-    statusLine: composeStatusLine(detection, recommendation, settings),
+    // The SAME autonomy facts the --status-line surface renders — the --json envelope must never
+    // expose a stale machine-composed status line (codex R1, Segment B).
+    statusLine: composeStatusLine(detection, recommendation, settings, autonomy),
   };
 };
 
@@ -404,10 +481,12 @@ Usage:
 
 Lists the four recipes (Solo / Reviewed / Council / Delegated) and, from the read-only backend
 detector, plans + recommends one for the current environment. --status-line prints exactly ONE
-line — the machine-composed backend-status summary the bootstrap/upgrade reports paste verbatim.
---active-line prints exactly ONE line — the CONFIGURED recipe per activity/slot, resolved from the
-per-project docs/ai/orchestration.json (read from the current directory) + live readiness, with
-degradation stated; paste it verbatim at session start / into the handover "Active recipes:" slot.
+line — the machine-composed backend-status summary the bootstrap/upgrade reports paste verbatim
+(incl. the per-activity autonomy segment: effective levels + render-sync state, honest
+computed-defaults wording when no policy file exists). --active-line prints exactly ONE line — the
+CONFIGURED recipe per activity/slot, resolved from the per-project docs/ai/orchestration.json (read
+from the current directory) + live readiness, with degradation stated and each activity's autonomy
+level beside its cells; paste it verbatim at session start / into the handover "Active recipes:" slot.
 --json emits the structured report (incl. the same line as \`statusLine\`); the three are mutually
 exclusive. Detection only — never writes, never commits, never runs a subscription CLI.`);
     return;
@@ -428,13 +507,13 @@ exclusive. Detection only — never writes, never commits, never runs a subscrip
     // so the config reader is pulled in at run time only — no static import cycle.
     const { loadConfig } = await import('./orchestration-config.mjs');
     try {
-      console.log(composeActiveRecipeLine(loadConfig(process.cwd()), detection));
+      console.log(composeActiveRecipeLine(loadConfig(process.cwd()), detection, await composeAutonomyFacts(process.cwd())));
     } catch (err) {
       console.error(`[agent-workflow-kit] ${err.message}`);
       return err.exitCode ?? 1;
     }
-  } else if (argv.includes('--status-line')) console.log(composeStatusLine(detection, recommendRecipe(detection), settingsSnapshot()));
-  else if (argv.includes('--json')) console.log(JSON.stringify(buildReport(detection, settingsSnapshot()), null, 2));
+  } else if (argv.includes('--status-line')) console.log(composeStatusLine(detection, recommendRecipe(detection), settingsSnapshot(), await composeAutonomyFacts(process.cwd())));
+  else if (argv.includes('--json')) console.log(JSON.stringify(buildReport(detection, settingsSnapshot(), await composeAutonomyFacts(process.cwd())), null, 2));
   else console.log(formatRecipes(detection));
   return 0;
 };