@felixdotgo/aidlc-kit 0.1.0 → 0.2.0

package/dist/assets/.agents/aidlc/scripts/loop-entry.mjs

@@ -1,90 +1,102 @@
 #!/usr/bin/env node
-import { execFileSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
+/**
+ * Loop entry point shared by `aidlc-kit loop`, the web dashboard, and operators.
+ *
+ *   start         start the singleton loop daemon for the configured mode (local or fleet)
+ *   intake        create a loop-owned task from a stdin requirement (≤ 8192 bytes) without running it
+ *   status        print the canonical task, loop record/checkpoint, and next action
+ *   worker-image  build and record a provider worker image
+ * Dashboard JSON actions (fleet authority; local dashboards read local state in-process):
+ *   tasks | task <id> | gate <id> | resume-task <id> | approve <id> (source on stdin,
+ *   reviewer credential only from AIDLC_FLEET_REVIEWER_TOKEN of this process)
+ *
+ * Positional arguments: [action, taskId, root, mode, provider, tag, title].
+ * Gate approval for local tasks stays on the trusted terminal (`loop-gate.mjs`).
+ */
+import { readFileSync } from "node:fs";
 import { resolve, join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { requireLocalAuthority } from "./lib/authority.mjs";
 import { isLoopProvider } from "./lib/loop-drivers.mjs";
-import { prepareLoopIntake } from "./lib/loop-intake.mjs";
+import { createLoopAuthority } from "./lib/loop-authority.mjs";
+import { runLoopDaemon } from "./lib/loop-daemon.mjs";
+import { streamLog } from "./lib/loop-stream.mjs";
 import * as localSupervisor from "./lib/loop-supervisor-run-local.mjs";
-import { loadTask } from "./lib/store.mjs";
+import { buildWorkerImage, defaultWorkerImageTag, recordWorkerImage } from "./lib/loop-worker-image.mjs";
 
-const [action, taskArg, rootArg, modeArg] = process.argv.slice(2);
+const [action, taskArg, rootArg, modeArg, providerArg, tagArg, titleArg] = process.argv.slice(2);
 const root = resolve(rootArg || ".");
-const readRequirement = async () => {
-  if (stdin.isTTY) { const rl = createInterface({ input: stdin, output: stdout }); try { return await rl.question("Requirement: "); } finally { rl.close(); } }
-  const chunks = []; for await (const chunk of stdin) { chunks.push(chunk); if (chunks.reduce((n, c) => n + c.length, 0) > 8192) throw new Error("Requirement exceeds 8192 bytes"); } return Buffer.concat(chunks).toString("utf8");
+const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const ACTIONS = ["start", "resume", "status", "intake", "tasks", "task", "gate", "resume-task", "approve"];
+const readStdin = async (prompt) => {
+  if (stdin.isTTY) { const rl = createInterface({ input: stdin, output: stdout }); try { return await rl.question(prompt); } finally { rl.close(); } }
+  const chunks = []; for await (const chunk of stdin) { chunks.push(chunk); if (chunks.reduce((n, c) => n + c.length, 0) > 8192) throw new Error("Input exceeds 8192 bytes"); } return Buffer.concat(chunks).toString("utf8");
 };
+const requireTaskId = () => { if (!ID.test(taskArg ?? "")) throw new Error("Valid task ID required"); return taskArg; };
+const print = (value) => console.log(JSON.stringify(value, null, 2));
+
 try {
-  if (!["start", "resume", "status"].includes(action)) throw new Error("Expected loop start, resume, or status");
-  const config = JSON.parse(readFileSync(join(root, ".agents", "config.json"), "utf8"));
-  const mode = modeArg || config.loop?.mode || "off";
-  if (!["local", "fleet"].includes(mode)) throw new Error("Loop mode is off; configure an enabled loop mode first");
-  if (mode !== config.loop?.mode) throw new Error("Requested mode does not match configured authority");
-  const agent = config.loop?.agents?.lead;
-  const workers = config.loop?.agents?.workers ?? {};
-  if (!isLoopProvider(agent) || !Object.keys(workers).length || Object.entries(workers).some(([, value]) => !isLoopProvider(value))) throw new Error("Loop requires a configured lead and worker providers");
-  const taskId = taskArg || (action === "start" ? `loop-${randomUUID()}` : "");
-  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(taskId)) throw new Error("Valid task ID required");
-  if (mode === "fleet") {
-    const { callRemoteTool } = await import("./lib/remote-state-client.mjs");
-    const { createFleetRemoteRepository } = await import("./lib/loop-fleet-remote.mjs");
-    const { runFleetCli } = await import("./lib/loop-fleet-cli.mjs");
-    const { readIntegrationCommit } = await import("./remote-state.mjs");
-    const requiredEnv = (name) => { const value = process.env[name]; if (typeof value !== "string" || !value.trim()) throw new Error(`Fleet loop requires ${name} for the configured remote authority`); return value; };
-    const url = requiredEnv("AIDLC_FLEET_URL"), workspace = requiredEnv("AIDLC_FLEET_WORKSPACE"), token = requiredEnv("AIDLC_FLEET_TOKEN");
-    const integrationBranch = requiredEnv("AIDLC_FLEET_INTEGRATION_BRANCH");
-    if (process.env.AIDLC_FLEET_PROJECT_ROOT && resolve(process.env.AIDLC_FLEET_PROJECT_ROOT) !== root) throw new Error("AIDLC_FLEET_PROJECT_ROOT does not match the loop root; refusing to run");
-    if (process.env.AIDLC_FLEET_WORKER_IDS && process.env.AIDLC_FLEET_WORKER_IDS.split(",").map((value) => value.trim()).filter(Boolean).join(",") !== Object.keys(workers).join(",")) throw new Error("AIDLC_FLEET_WORKER_IDS does not match the configured loop workers");
-    if (process.env.AIDLC_FLEET_WORKER_PROVIDERS && process.env.AIDLC_FLEET_WORKER_PROVIDERS !== JSON.stringify(workers)) throw new Error("AIDLC_FLEET_WORKER_PROVIDERS does not match the configured loop workers");
-    const env = { ...process.env, AIDLC_FLEET_PROJECT_ROOT: root, AIDLC_FLEET_WORKER_IDS: Object.keys(workers).join(","), AIDLC_FLEET_WORKER_PROVIDERS: JSON.stringify(workers), AIDLC_FLEET_AGENT: agent };
-    const remoteState = join(root, ".agents/aidlc/scripts/remote-state.mjs");
-    if (!existsSync(remoteState)) throw new Error(`Remote lifecycle CLI is missing: ${remoteState}`);
-    const callTool = ({ url: serviceUrl, token: serviceToken, name, args }) => callRemoteTool({ url: serviceUrl, token: serviceToken }, name, args);
-    const repository = createFleetRemoteRepository({ callTool, url, token, workspace, root });
-    if (action === "status") {
-      let snapshot = null;
-      try { snapshot = await repository.readTask({ taskId }); } catch (error) { if (!String(error?.message ?? error).includes("task not found")) throw error; }
-      const checkpoint = await repository.readGateCheckpoint({ taskId });
-      console.log(JSON.stringify({ taskId, authority: "fleet", task: snapshot?.task ?? null, nextAction: snapshot?.nextAction ?? null, checkpoint }, null, 2));
+  if (action === "worker-image") {
+    // Build (or rebuild) a worker image without requiring loop configuration.
+    const provider = providerArg || "opencode";
+    if (!isLoopProvider(provider)) throw new Error("Expected --provider codex, claude, or opencode");
+    const image = tagArg || defaultWorkerImageTag(provider);
+    buildWorkerImage({ root, provider, image });
+    recordWorkerImage({ root, provider, image });
+    console.log(`Built worker image: ${image}`);
+    console.log("Recorded worker image; the loop supervisor will use it automatically.");
+  } else {
+    if (!ACTIONS.includes(action)) throw new Error("Expected loop start, status, intake, or worker-image");
+    const config = JSON.parse(readFileSync(join(root, ".agents", "config.json"), "utf8"));
+    const mode = modeArg || config.loop?.mode || "off";
+    if (!["local", "fleet"].includes(mode)) throw new Error("Loop mode is off; configure an enabled loop mode first");
+    if (mode !== config.loop?.mode) throw new Error("Requested mode does not match configured authority");
+    const agent = config.loop?.agents?.lead;
+    const workers = config.loop?.agents?.workers ?? {};
+    if (!isLoopProvider(agent) || !Object.keys(workers).length || Object.entries(workers).some(([, value]) => !isLoopProvider(value))) throw new Error("Loop requires a configured lead and worker providers");
+    if (action === "resume") throw new Error("loop resume is removed; the daemon auto-resumes actionable tasks — run 'loop start', and re-activate a paused task from the dashboard (resume) or with the task status command");
+    if (mode === "local") requireLocalAuthority();
+    if (mode === "local" && action === "status") {
+      const supervisor = await localSupervisor.createIsolatedLocalSupervisor({ root, taskId: requireTaskId(), agent, workers, workerImages: config.loop?.workerImage, onEvent: streamLog });
+      print(await supervisor.status());
     } else {
-      if (action === "resume") {
-        const recordPath = join(root, ".agents/data/tasks", taskId, "loop-intake.json");
-        if (!existsSync(recordPath)) throw new Error("Loop record missing; use start");
-        const record = JSON.parse(readFileSync(recordPath, "utf8"));
-        if (record.taskId !== taskId || record.authority !== "fleet") throw new Error("Loop record authority mismatch; use the recorded authority and task");
-      }
-      await callRemoteTool({ url, token }, "fleet_get", { workspace });
-      await readIntegrationCommit({ projectRoot: root, integrationBranch, gitRemote: env.AIDLC_FLEET_GIT_REMOTE ?? "origin" });
+      const authority = await createLoopAuthority({ root, config });
       if (action === "start") {
-        const requirement = await readRequirement();
-        const readTask = async (id) => { try { return (await callRemoteTool({ url, token }, "task_get", { workspace, taskId: id, clientProjectRoot: root })).task; } catch { return null; } };
-        const current = await callRemoteTool({ url, token }, "state_get", { workspace });
-        const actionable = Object.values(current?.state?.tasks ?? {}).filter((task) => task.id !== taskId && task.status === "active" && !task.handoff);
-        if (actionable.length) throw new Error(`Task create is blocked while other work is actionable: ${actionable.map((task) => task.id).join(", ")}`);
-        await prepareLoopIntake({ root, taskId, requirement, authority: "fleet", readTask, createTask: async ({ taskId: id, title }) => {
-          const claim = await repository.claimLead({ taskId: id, leaseMs: 60000 });
-          try {
-            execFileSync(process.execPath, [remoteState, "task", "create", id, "--title", title], { cwd: root, encoding: "utf8", env: { ...env, AIDLC_FLEET_LEAD_EPOCH: String(claim.epoch), AIDLC_FLEET_LEAD_OWNER_TOKEN: repository.leadOwnerToken() } });
-          } finally { await repository.releaseLead({ taskId: id, epoch: claim.epoch }); }
-        } });
+        // Two-stage shutdown: 1st signal stops after the current turn, 2nd cancels
+        // the in-flight agent turn, 3rd exits immediately. Runs end as `stopped`
+        // (tasks are not paused) and resume on the next daemon start.
+        const stop = new AbortController(), cancel = new AbortController();
+        let received = 0;
+        const onSignal = () => {
+          received += 1;
+          if (received === 1) { process.stderr.write("\nloop: stopping after the current turn — send the signal again (Ctrl-C) to cancel it\n"); stop.abort(); }
+          else if (received === 2) { process.stderr.write("\nloop: cancelling the in-flight turn — send the signal again to exit immediately\n"); cancel.abort(); }
+          else process.exit(130);
+        };
+        for (const name of ["SIGINT", "SIGTERM"]) process.on(name, onSignal);
+        if (typeof authority.preflight === "function") await authority.preflight();
+        print(await runLoopDaemon({ root, authority, pollMs: config.loop?.pollMs, signal: stop.signal, cancelSignal: cancel.signal, onEvent: streamLog }));
+      } else if (action === "intake") {
+        print(await authority.intake({ requirement: await readStdin("Requirement: "), taskId: taskArg || undefined, title: titleArg || undefined }));
+      } else if (action === "resume-task") {
+        print(await authority.resumeTask(requireTaskId()));
+      } else if (mode !== "fleet") {
+        throw new Error(`loop ${action} is a fleet dashboard action; local dashboards read canonical local state directly`);
+      } else if (action === "status") {
+        const taskId = requireTaskId();
+        const snapshot = await authority.getTask(taskId);
+        print({ taskId, authority: "fleet", task: snapshot.task, nextAction: snapshot.nextAction, checkpoint: await authority.repository.readGateCheckpoint({ taskId }) });
+      } else if (action === "tasks") {
+        print({ ok: true, authority: "fleet", tasks: await authority.listTasks() });
+      } else if (action === "task") {
+        print({ ok: true, authority: "fleet", ...(await authority.getTask(requireTaskId())) });
+      } else if (action === "gate") {
+        print({ ok: true, authority: "fleet", ...(await authority.gate(requireTaskId())) });
+      } else if (action === "approve") {
+        const taskId = requireTaskId();
+        print(await authority.approve({ taskId, source: (await readStdin("Approval source: ")).trim(), reviewerToken: process.env.AIDLC_FLEET_REVIEWER_TOKEN }));
       }
-      await runFleetCli(["supervisor", taskId], { callTool, env, out: (line) => console.log(line) });
     }
-  } else {
-    requireLocalAuthority();
-    // The factory contract guarantees that the dispatcher is actually wired into
-    // the supervisor, not merely present in the package. No host fallback.
-    if (typeof localSupervisor.createIsolatedLocalSupervisor !== "function") throw new Error("Isolated local worker dispatcher is not integrated; loop execution is unavailable");
-    const supervisor = await localSupervisor.createIsolatedLocalSupervisor({ root, taskId, agent, workers: config.loop.agents.workers });
-    if (action === "status") {
-      console.log(JSON.stringify(await supervisor.status(), null, 2));
-    } else if (action === "start") {
-      const requirement = await readRequirement();
-      await prepareLoopIntake({ root, taskId, requirement, authority: "local", readTask: async (id) => loadTask(root, id), createTask: async ({ taskId: id, title }) => { execFileSync(process.execPath, [join(root, ".agents/aidlc/scripts/state.mjs"), "task", "create", id, "--title", title, "--root", root], { stdio: ["ignore", "pipe", "pipe"] }); } });
-      console.log(JSON.stringify(await supervisor.start(), null, 2));
-    } else console.log(JSON.stringify(await supervisor.resume(), null, 2));
   }
 } catch (error) { console.error(`loop: ${error.message}`); process.exitCode = 1; }

package/dist/assets/.agents/aidlc/scripts/loop-gate.mjs

@@ -41,18 +41,30 @@ async function main() {
   console.log(review.view.trimEnd());
   console.log(`Review identity: ${JSON.stringify({ taskId, phase: review.phase, gate: review.gate, taskHash: review.taskHash, artifacts: review.artifacts, integrationCommit: review.commit })}`);
   const rl = createInterface({ input: stdin, output: stdout });
-  let answer; try { answer = await rl.question("Type approve to approve this exact review: "); } finally { rl.close(); }
-  if (answer.trim() !== "approve") throw new Error("Review was not approved");
+  let answer; try { answer = await rl.question("Type approve to approve this exact review, or type feedback to send guidance back to the loop: "); } finally { rl.close(); }
+  const trimmed = answer.trim();
+  if (!trimmed) throw new Error("Review was not approved");
   release = acquireStateLock(root);
   try {
     const state = loadState(root), fresh = snapshot(root, taskId, state);
     if (digest({ ...fresh, view: undefined }) !== digest({ ...review, view: undefined })) throw new Error("Review changed while waiting for approval; inspect the new review");
-    const checkpoint = readLocalGateCheckpoint(root, state.tasks[taskId]);
+    const task = state.tasks[taskId];
     const reviewHash = digest({ ...review, view: undefined });
-    const outcome = approveAndAdvance(root, state, taskId, review.gate, `Trusted host terminal: approve (${reviewHash})`);
-    saveState(root, state);
-    writeLocalGateReceipt(root, checkpoint, outcome.task, reviewHash);
-    console.log(`Approved ${review.gate}; next action: ${JSON.stringify(outcome.nextAction)}`);
+    if (trimmed === "approve") {
+      const checkpoint = readLocalGateCheckpoint(root, task);
+      const outcome = approveAndAdvance(root, state, taskId, review.gate, `Trusted host terminal: approve (${reviewHash})`);
+      saveState(root, state);
+      writeLocalGateReceipt(root, checkpoint, outcome.task, reviewHash);
+      console.log(`Approved ${review.gate}; next action: ${JSON.stringify(outcome.nextAction)}`);
+    } else {
+      const recordedAt = new Date().toISOString();
+      task.evidence.push({ kind: "diagnostic", result: "pass", source: `Trusted host terminal: feedback (${reviewHash})`, detail: `Cancelled gate wait at ${task.gate}: ${trimmed}`, recordedAt });
+      delete task.legacyG2Wait;
+      task.status = "active";
+      task.updatedAt = recordedAt;
+      saveState(root, state);
+      console.log(`Feedback recorded at ${review.gate}; the loop will revise the review and re-present the gate`);
+    }
   } finally { release(); }
 }
 main().catch((error) => { console.error(`loop-gate: ${error.message}`); process.exitCode = 1; });

package/dist/assets/.agents/aidlc/scripts/loop.mjs

@@ -2,6 +2,7 @@
 import { resolve } from "node:path";
 import { loopStatus, runLoop } from "./lib/loop-runtime.mjs";
 import { LOOP_PROVIDERS, runAgentTurn } from "./lib/loop-drivers.mjs";
+import { streamLog } from "./lib/loop-stream.mjs";
 import { requireLocalAuthority } from "./lib/authority.mjs";
 
 function parse(argv) {
@@ -27,7 +28,7 @@ function parse(argv) {
 try {
   requireLocalAuthority();
   const options = parse(process.argv.slice(2));
-  const result = options.command === "status" ? loopStatus(options.root, options.taskId) : await runLoop({ root: options.root, taskId: options.taskId, agent: options.agent, mode: options.command, limits: options.limits, driver: runAgentTurn, preflight: true, onEvent: (event) => { if (event?.type === "diagnostic") console.error(event.message); if (event?.type === "resume" || event?.type === "context_changed") console.error(JSON.stringify(event)); } });
+  const result = options.command === "status" ? loopStatus(options.root, options.taskId) : await runLoop({ root: options.root, taskId: options.taskId, agent: options.agent, mode: options.command, limits: options.limits, driver: runAgentTurn, preflight: true, onEvent: (event) => { streamLog(event); if (event?.type === "diagnostic") console.error(event.message); if (event?.type === "resume" || event?.type === "context_changed") console.error(JSON.stringify(event)); } });
   console.log(JSON.stringify({ ok: true, result }, null, 2));
   if (result.status && !["complete", "gate"].includes(result.status)) process.exitCode = 2;
 } catch (error) {

package/dist/assets/.agents/aidlc/scripts/remote-state.mjs

@@ -69,6 +69,7 @@ export const runRemoteState = async (argv, client, root, git = {}) => {
   if (!extra && ["task item", "decision set", "lesson record"].includes(route)) throw new Error(`${route} requires an item/decision/lesson id`);
 
   const current = await client.get();
+  // --- Read-only routes ------------------------------------------------------
   if (!Number.isSafeInteger(current?.revision) || !current?.state?.tasks) throw new Error("Remote coordination returned invalid canonical state");
   const state = current.state;
   const previous = state.tasks[id];
@@ -100,6 +101,7 @@ export const runRemoteState = async (argv, client, root, git = {}) => {
     return { ok: true, result: await client.snapshot(current.revision, id, gate, reviewText, integrationCommit) };
   }
 
+  // --- Mutating routes -------------------------------------------------------
   let task;
   if (route === "task create") {
     if (previous || state.archive?.[id]) throw new Error(`Task already exists: ${id}`);

package/dist/assets/.agents/aidlc/scripts/state.mjs

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+/**
+ * AI-DLC lifecycle CLI. Parses argv, dispatches to the canonical state module,
+ * and emits the JSON result with the nextAction for the lead.
+ */
 import { acquireStateLock, approveAndAdvance, checkGate, closeTask, failEntry, handoffTask, listTaskSummaries, loadMemoryRegistry, loadState, loadTask, migrateState, nextAction, option, parseArguments, promoteAgenticMemory, rebuildLessonIndex, recordLesson, recordNoLessons, renderViews, reopenTask, retireAgenticMemory, rootOption, saveState, searchLessons, supersedeTask, transitionTask, validateArguments } from "./lib/runtime.mjs";
 import { readLiveLease } from "./lib/loop-lease.mjs";
 import { listFeatures, loadFeature, readyFeatureTasks, saveFeature } from "./lib/feature-store.mjs";

package/dist/assets/.agents/aidlc/templates/design.md

@@ -11,5 +11,14 @@
 ## 🔗 Cross-service contracts
 - <contract or `none`>
 
+## 🔀 Parallel work partition
+| item | owned paths | depends on | verification |
+|------|-------------|------------|--------------|
+| <item-id> | <paths it alone writes> | <item-ids or `none`> | <narrow command> |
+
+- One owner per path among items that can run at the same time; overlapping items must be ordered with `dependsOn`.
+- Shared surfaces (barrel/index files, shared config, cross-cutting docs, a single entry script) get exactly one owning item; others depend on it.
+- Prefer file/module-level ownership over broad parent directories.
+
 ## ⚠️ Risks / edge cases
 - <risk and mitigation>

package/dist/assets/.agents/aidlc/templates/intent.md

@@ -6,6 +6,10 @@
 ## 🗺️ Affected areas
 - `<area>` — <why> — spec: <indexed source or `none indexed`>
 
+## 🔀 Work boundaries
+- `<work stream>` — <code areas/paths it touches> — <independent of / depends on>
+- or `single stream` — <why the work cannot be split>
+
 ## 💭 Assumptions
 - <assumption>
 

package/dist/assets/.agents/aidlc/templates/workplan.md

@@ -6,4 +6,4 @@
 - <generated decision state>
 
 ## 🧩 Tasks (Review implementation — work items)
-- <generated task state>
+- <generated task state — each line shows `owns: <paths> · after: <item-ids>`>

package/dist/assets/.agents/skills/aidlc-plan/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: aidlc-plan
-description: "AI-DLC phase 2 (Approve plan): after intent is confirmed, run bounded discovery, then produce a detailed design, canonical decisions, and a per-submodule workplan. Triggers when the AI-DLC Orchestrator routes a task after requirements confirmation to planning. Ends at the executable Approve plan review for explicit user approval."
+description: "AI-DLC phase 2 (Approve plan): after intent is confirmed, run bounded discovery, then produce a detailed design, canonical decisions, and a per-submodule workplan whose items own non-overlapping paths so parallel workers do not collide. Triggers when the AI-DLC Orchestrator routes a task after requirements confirmation to planning. Ends at the executable Approve plan review for explicit user approval."
 ---
 
 # AI-DLC · Plan (Approve plan) — adapter