@mobrienv/autoloop 0.4.0 → 0.7.0

package/dist/worktree/merge.js

@@ -1,129 +0,0 @@
-import { execSync } from "node:child_process";
-import { shellQuote } from "../utils.js";
-import { readMeta, updateStatus } from "./meta.js";
-const DEFAULT_GIT_NAME = "autoloop";
-const DEFAULT_GIT_EMAIL = "autoloop@local";
-export function mergeWorktree(opts) {
-    const { mainProjectDir, metaDir, strategy = "squash" } = opts;
-    const meta = readMeta(metaDir);
-    if (!meta)
-        throw new Error(`no worktree meta found in ${metaDir}`);
-    validateMergeStatus(meta);
-    const baseBranch = meta.base_branch;
-    const branch = meta.branch;
-    const gitEnv = resolveGitEnv(mainProjectDir);
-    // Checkout base branch
-    exec(mainProjectDir, `git checkout ${shellQuote(baseBranch)}`, gitEnv);
-    try {
-        if (strategy === "squash") {
-            exec(mainProjectDir, `git merge --squash ${shellQuote(branch)}`, gitEnv);
-            exec(mainProjectDir, `git commit --no-edit -m ${shellQuote(`merge worktree ${meta.run_id} (squash)`)}`, gitEnv);
-        }
-        else if (strategy === "rebase") {
-            exec(mainProjectDir, `git rebase ${shellQuote(branch)}`, gitEnv);
-        }
-        else {
-            exec(mainProjectDir, `git merge --no-ff ${shellQuote(branch)} -m ${shellQuote(`merge worktree ${meta.run_id}`)}`, gitEnv);
-        }
-    }
-    catch (err) {
-        // Attempt to detect conflicts and abort
-        const msg = err instanceof Error ? err.message : String(err);
-        const conflicts = detectConflicts(mainProjectDir);
-        try {
-            if (strategy === "rebase") {
-                exec(mainProjectDir, "git rebase --abort", gitEnv);
-            }
-            else {
-                exec(mainProjectDir, "git merge --abort", gitEnv);
-            }
-        }
-        catch {
-            /* abort best-effort */
-        }
-        if (conflicts.length > 0) {
-            return {
-                success: false,
-                conflicts,
-                recoveryHint: `Resolve conflicts manually, then run: git merge ${branch}`,
-            };
-        }
-        throw new Error(`merge failed: ${msg}`);
-    }
-    updateStatus(metaDir, "merged");
-    return { success: true };
-}
-function validateMergeStatus(meta) {
-    if (meta.status === "running") {
-        throw new Error(`cannot merge worktree ${meta.run_id}: still running`);
-    }
-    if (meta.status === "merged") {
-        throw new Error(`worktree ${meta.run_id} is already merged`);
-    }
-    if (meta.status === "removed") {
-        throw new Error(`worktree ${meta.run_id} has been removed`);
-    }
-}
-function detectConflicts(cwd) {
-    try {
-        const out = execSync("git diff --name-only --diff-filter=U", {
-            cwd,
-            encoding: "utf-8",
-            stdio: "pipe",
-        }).trim();
-        return out ? out.split("\n") : [];
-    }
-    catch {
-        return [];
-    }
-}
-function resolveGitEnv(cwd) {
-    const configuredName = readGitConfig(cwd, "user.name");
-    const configuredEmail = readGitConfig(cwd, "user.email");
-    const hasIdentityEnv = hasText(process.env.GIT_AUTHOR_NAME) ||
-        hasText(process.env.GIT_AUTHOR_EMAIL) ||
-        hasText(process.env.GIT_COMMITTER_NAME) ||
-        hasText(process.env.GIT_COMMITTER_EMAIL);
-    if (!hasIdentityEnv && configuredName && configuredEmail) {
-        return undefined;
-    }
-    const fallbackName = textOr(process.env.AUTOLOOP_GIT_NAME, DEFAULT_GIT_NAME);
-    const fallbackEmail = textOr(process.env.AUTOLOOP_GIT_EMAIL, DEFAULT_GIT_EMAIL);
-    const authorName = textOr(process.env.GIT_AUTHOR_NAME) ?? configuredName ?? fallbackName;
-    const authorEmail = textOr(process.env.GIT_AUTHOR_EMAIL) ?? configuredEmail ?? fallbackEmail;
-    const committerName = textOr(process.env.GIT_COMMITTER_NAME) ?? configuredName ?? authorName;
-    const committerEmail = textOr(process.env.GIT_COMMITTER_EMAIL) ?? configuredEmail ?? authorEmail;
-    return {
-        ...process.env,
-        GIT_AUTHOR_NAME: authorName,
-        GIT_AUTHOR_EMAIL: authorEmail,
-        GIT_COMMITTER_NAME: committerName,
-        GIT_COMMITTER_EMAIL: committerEmail,
-    };
-}
-function readGitConfig(cwd, key) {
-    try {
-        const value = execSync(`git config --get ${shellQuote(key)}`, {
-            cwd,
-            encoding: "utf-8",
-            stdio: "pipe",
-        }).trim();
-        return value === "" ? undefined : value;
-    }
-    catch {
-        return undefined;
-    }
-}
-function hasText(value) {
-    return value !== undefined && value.trim() !== "";
-}
-function textOr(value, fallback) {
-    if (value === undefined)
-        return fallback;
-    const trimmed = value.trim();
-    return trimmed === "" ? fallback : trimmed;
-}
-function exec(cwd, cmd, env) {
-    return execSync(cmd, { cwd, encoding: "utf-8", env, stdio: "pipe" });
-}
-//# sourceMappingURL=merge.js.map

package/dist/worktree/merge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../src/worktree/merge.ts"],"names":[],"mappings":"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"}

package/dist/worktree/meta.d.ts

@@ -1,17 +0,0 @@
-export type WorktreeStatus = "running" | "completed" | "failed" | "merged" | "removed";
-export interface WorktreeMeta {
-    run_id: string;
-    branch: string;
-    worktree_path: string;
-    base_branch: string;
-    status: WorktreeStatus;
-    merge_strategy: string;
-    created_at: string;
-    merged_at: string | null;
-    removed_at: string | null;
-}
-export declare function metaDirForRun(mainStateDir: string, runId: string): string;
-export declare function writeMeta(metaDir: string, meta: WorktreeMeta): void;
-export declare function readMeta(metaDir: string): WorktreeMeta | null;
-export declare function isOrphanWorktree(meta: WorktreeMeta): boolean;
-export declare function updateStatus(metaDir: string, status: WorktreeStatus): void;

package/dist/worktree/meta.js

@@ -1,34 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-const META_FILE = "meta.json";
-export function metaDirForRun(mainStateDir, runId) {
-    return join(mainStateDir, "worktrees", runId);
-}
-export function writeMeta(metaDir, meta) {
-    mkdirSync(metaDir, { recursive: true });
-    const target = join(metaDir, META_FILE);
-    const tmp = `${target}.tmp`;
-    writeFileSync(tmp, `${JSON.stringify(meta, null, 2)}\n`);
-    renameSync(tmp, target);
-}
-export function readMeta(metaDir) {
-    const target = join(metaDir, META_FILE);
-    if (!existsSync(target))
-        return null;
-    return JSON.parse(readFileSync(target, "utf-8"));
-}
-export function isOrphanWorktree(meta) {
-    return meta.status !== "removed" && !existsSync(meta.worktree_path);
-}
-export function updateStatus(metaDir, status) {
-    const meta = readMeta(metaDir);
-    if (!meta)
-        throw new Error(`no worktree meta found in ${metaDir}`);
-    meta.status = status;
-    if (status === "merged")
-        meta.merged_at = new Date().toISOString();
-    if (status === "removed")
-        meta.removed_at = new Date().toISOString();
-    writeMeta(metaDir, meta);
-}
-//# sourceMappingURL=meta.js.map

package/dist/worktree/meta.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"meta.js","sourceRoot":"","sources":["../../src/worktree/meta.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,SAAS,EACT,YAAY,EACZ,UAAU,EACV,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAqBjC,MAAM,SAAS,GAAG,WAAW,CAAC;AAE9B,MAAM,UAAU,aAAa,CAAC,YAAoB,EAAE,KAAa;IAC/D,OAAO,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,OAAe,EAAE,IAAkB;IAC3D,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACxC,MAAM,GAAG,GAAG,GAAG,MAAM,MAAM,CAAC;IAC5B,aAAa,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;IACzD,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,OAAe;IACtC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACxC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,CAAiB,CAAC;AACnE,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAkB;IACjD,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;AACtE,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,OAAe,EAAE,MAAsB;IAClE,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC/B,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,6BAA6B,OAAO,EAAE,CAAC,CAAC;IACnE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACrB,IAAI,MAAM,KAAK,QAAQ;QAAE,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnE,IAAI,MAAM,KAAK,SAAS;QAAE,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACrE,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC3B,CAAC"}

package/presets/autocode/README.md

@@ -1,81 +0,0 @@
-# Autocode miniloop
-
-Use when you need to implement a feature, refactor code, or make structured changes across a codebase.
-
-Shape:
-- planner
-- builder
-- critic
-- finalizer
-
-Shared state lives in project files plus the autoloops journal. One active step is tracked in `.autoloop/progress.md`.
-
-## Fail-closed contract
-
-Autocode is not an approval machine.
-
-- Planner decomposes work into the next smallest slice.
-- Builder implements and proves the slice.
-- Critic tries to break the slice, including independently running a manual smoke test that exercises the builder's changed code path whenever a practical manual surface is available, and rejects on missing evidence.
-- Finalizer tries to prove the whole task is still incomplete before allowing completion.
-
-Success is evidence-based, not prose-based. Only the finalizer may emit `task.complete`.
-
-## Files
-
-- `autoloops.toml` — loop + backend config
-- `topology.toml` — role deck + handoff graph
-- `harness.md` — shared harness rules loaded every iteration
-- `roles/planner.md`
-- `roles/build.md`
-- `roles/critic.md`
-- `roles/finalizer.md`
-
-## Shared working files created by the loop
-
-The planner is expected to create and maintain:
-- `.autoloop/context.md`
-- `.autoloop/plan.md`
-- `.autoloop/progress.md`
-- `.autoloop/logs/`
-
-## Backend
-
-This preset assumes the built-in Pi adapter:
-
-```toml
-backend.kind = "pi"
-backend.command = "pi"
-```
-
-Pi is the only supported real adapter path here.
-
-For deterministic local harness debugging only, switch to the repo mock backend:
-
-```toml
-backend.kind = "command"
-backend.command = "../../examples/mock-backend.sh"
-```
-
-## Run
-
-From this repo root:
-
-```bash
-autoloop run autocode "Add a --verbose flag to the CLI"
-```
-
-For a one-off Claude dogfood run without editing config:
-
-```bash
-autoloop -b claude -p autocode "Add a --verbose flag to the CLI"
-```
-
-## Intended input styles
-
-The planner prompt supports the same three broad entry modes as Ralph's code-assist preset:
-- a rough implementation request
-- a single `.code-task.md` file path
-- an existing implementation/spec directory
-
-The planner must normalize that into the shared working files and then hand off one concrete next slice.

package/presets/autocode/autoloops.toml

@@ -1,30 +0,0 @@
-event_loop.max_iterations = 100
-event_loop.completion_event = "task.complete"
-event_loop.completion_promise = "LOOP_COMPLETE"
-# Require the critic and finalizer gates before completion is considered valid.
-event_loop.required_events = ["review.passed"]
-
-backend.kind = "command"
-backend.command = "claude"
-backend.timeout_ms = 3000000
-# For deterministic local harness testing only:
-# backend.kind = "command"
-# backend.command = "../../examples/mock-backend.sh"
-
-review.enabled = true
-review.timeout_ms = 300000
-
-memory.prompt_budget_chars = 8000
-harness.instructions_file = "harness.md"
-
-core.state_dir = ".autoloop"
-core.journal_file = ".autoloop/journal.jsonl"
-core.memory_file = ".autoloop/memory.jsonl"
-
-# Kiro backend (persistent ACP session):
-# backend.kind = "kiro"
-# backend.command = "kiro-cli"
-# backend.args = ["acp"]
-# backend.trust_all_tools = true
-# backend.agent = ""
-# backend.model = ""

package/presets/autocode/harness.md

@@ -1,26 +0,0 @@
-This project is a autoloops-native port of Ralph's code-assist/autocode preset.
-
-Global rules:
-- Shared working files are the source of truth: `{{STATE_DIR}}/context.md`, `{{STATE_DIR}}/plan.md`, `{{STATE_DIR}}/progress.md`, and `{{STATE_DIR}}/logs/`.
-- Keep only one concrete slice active at a time.
-- Use the event tool instead of prose-only handoffs.
-- Fresh context every iteration: re-read the shared working files and the relevant source before acting.
-- Prefer small, verifiable changes.
-- Verification is mandatory before `review.ready`, `review.passed`, or `task.complete`.
-- The critic should independently run a manual smoke test that exercises the builder's changed code path whenever the repo exposes a practical manual surface; otherwise the critic should say why no such smoke path exists.
-- Missing evidence means no success. No role may treat another role's assertion as proof.
-- Every success handoff should cite exact files changed, exact verification command(s), and commit hash when applicable.
-- After a slice is implemented and verified, commit it before `review.ready` or any later handoff. Every completed slice should land as its own commit. Avoid carrying verified but uncommitted work into the next iteration.
-- Do not dismiss a relevant issue as merely pre-existing. If it matters to the current objective, touched surface, or verification path, you must fix it now, make it the next slice, explicitly defer it with rationale in `{{STATE_DIR}}/progress.md`, or prove it is out of scope.
-- Maintain a `Relevant Issues` section in `{{STATE_DIR}}/progress.md`. Every relevant issue must have an explicit disposition: `fix-now`, `fix-next`, `deferred`, or `out-of-scope`.
-- Use `{{TOOL_PATH}} memory add learning ...` for durable repo/process learnings.
-- Do not invent extra phases. Stay inside planner → builder → critic → finalizer.
-- Only the finalizer may emit `task.complete`.
-- If the prompt is a path to a `.code-task.md` file or an existing implementation directory, use that as source material instead of treating it like plain prose.
-
-Role boundaries (strict):
-- The planner MUST NOT implement code, run tests, or make commits. It writes shared working files and emits `tasks.ready`.
-- The builder implements the active slice, verifies it, commits it, and emits `review.ready`. It does not plan or review.
-- The critic independently verifies the builder's work and emits `review.passed` or `review.rejected`. It does not build.
-- The finalizer checks whole-task completeness and emits `queue.advance` or `task.complete`.
-- If the routing topology says your next event is X, emit X — do not attempt completion or skip-ahead events.

package/presets/autocode/miniloops.toml

@@ -1,22 +0,0 @@
-event_loop.max_iterations = 100
-event_loop.completion_event = "task.complete"
-event_loop.completion_promise = "LOOP_COMPLETE"
-# Require the critic and finalizer gates before completion is considered valid.
-event_loop.required_events = ["review.passed"]
-
-backend.kind = "pi"
-backend.command = "pi"
-backend.timeout_ms = 3000000
-# For deterministic local harness testing only:
-# backend.kind = "command"
-# backend.command = "../../examples/mock-backend.sh"
-
-review.enabled = true
-review.timeout_ms = 300000
-
-memory.prompt_budget_chars = 8000
-harness.instructions_file = "harness.md"
-
-core.state_dir = ".miniloop"
-core.journal_file = ".miniloop/journal.jsonl"
-core.memory_file = ".miniloop/memory.jsonl"

package/presets/autocode/roles/build.md

@@ -1,34 +0,0 @@
-You are the builder.
-
-Implement exactly the active slice from the latest `tasks.ready` handoff.
-
-On every activation:
-- Re-read `{{STATE_DIR}}/context.md`, `{{STATE_DIR}}/plan.md`, and `{{STATE_DIR}}/progress.md`.
-- Re-read the source files named in the current slice.
-- Update `{{STATE_DIR}}/progress.md` with what you are doing and how you will verify it.
-
-Process:
-1. Understand the active slice and its acceptance criteria.
-2. Prefer test-first work when the repo has a test harness for the area.
-3. Make the smallest code change that satisfies the slice.
-4. Run the strongest focused verification you can for that slice.
-5. Commit the completed slice before handoff. Each completed slice should land as its own commit.
-6. Record concise evidence in `{{STATE_DIR}}/progress.md` and longer output in `{{STATE_DIR}}/logs/` when useful, including the commit hash when available.
-7. Emit `review.ready` with:
-   - what changed
-   - what was verified
-   - the slice commit hash
-   - any known risk or uncertainty
-
-If blocked:
-- Record the reason in `{{STATE_DIR}}/progress.md`.
-- Emit `build.blocked` with a concrete blocker and the safest next planning move.
-
-Rules:
-- One slice per turn.
-- No opportunistic side quests.
-- No final completion decisions.
-- No fake verification.
-- Do not emit `review.ready` for an uncommitted completed slice.
-- If confidence is shaky, choose the narrower, more reversible change and document why.
-- You MUST emit `review.ready` (or `build.blocked`) — never `review.passed`, `task.complete`, or any other event. The critic reviews your work; you do not self-approve.

package/presets/autocode/roles/critic.md

@@ -1,40 +0,0 @@
-You are the critic.
-
-You are not the builder. Fresh eyes matter.
-
-Your job is to challenge the latest increment and try to prove it is not ready.
-
-On activation:
-- Re-read `{{STATE_DIR}}/context.md`, `{{STATE_DIR}}/plan.md`, and `{{STATE_DIR}}/progress.md`.
-- Inspect the changed files and the builder's stated verification.
-- Re-run the strongest relevant checks yourself when possible.
-- Run at least one manual smoke test that actually exercises the builder's changed code path whenever the repo exposes a practical manual surface (for example an existing smoke script, CLI invocation, dev server flow, or reproducible app path). Run it yourself instead of relying only on the builder's checks. If no practical manual smoke path exists, say that explicitly.
-- Treat the builder's summary as a hint, not proof.
-
-Review checklist:
-- Did the builder actually satisfy the active slice?
-- Did they silently skip an obvious edge case or acceptance criterion?
-- Is there needless complexity or speculative work?
-- Does the code fit the surrounding repo style?
-- Did the claimed verification really cover the change?
-- Did you run your own manual smoke test that exercised the builder's changed code path when a practical manual path existed?
-- Can you independently validate the claim from code plus evidence?
-- Is the verified slice committed, with `git status --short` clean except for intentional unrelated files?
-- Were all relevant issues discovered during the slice given an explicit disposition in `{{STATE_DIR}}/progress.md`?
-- Did anyone try to dismiss a relevant issue just because it was pre-existing?
-
-Emit (only these two events — never emit builder events like `review.ready` or `build.blocked`):
-- `review.rejected` when there is a concrete miss, bug, regression risk, failed verification, untested acceptance criterion, overbuilt solution worth fixing now, verified-but-uncommitted work that should be committed before handoff, or any relevant issue that was left unowned / untracked / ambiguously deferred.
-- `review.passed` only when the current slice survives skeptical review, the verified slice is committed, and all relevant issues have explicit ownership or disposition.
-
-Rules:
-- Default to rejection when evidence is incomplete.
-- Be concrete, not vague.
-- Prefer one strong objection over a pile of weak ones.
-- Do not rewrite the whole solution unless the current slice is fundamentally wrong.
-- Do not approve with "fix later" caveats.
-- If checks passed but the builder left the repo dirty, require a commit before `review.passed`.
-- Reject any slice that mentions or reveals a relevant issue without recording whether it is `fix-now`, `fix-next`, `deferred`, or `out-of-scope`.
-- `pre-existing` is never by itself a valid reason to ignore a relevant issue.
-- If you cannot independently validate the builder's claim from code plus evidence, reject.
-- If the changed code had a practical manual execution path and you did not run it yourself, treat the evidence as incomplete and reject. If no such path existed, say that explicitly.

package/presets/autocode/roles/finalizer.md

@@ -1,43 +0,0 @@
-You are the finalizer.
-
-You are the last gate before loop completion.
-
-Your job is not just to ask whether the latest diff is okay.
-Your job is to decide whether the whole requested outcome is complete or whether the loop should continue.
-
-On activation:
-- Re-read `{{STATE_DIR}}/context.md`, `{{STATE_DIR}}/plan.md`, and `{{STATE_DIR}}/progress.md`.
-- Reconcile the latest reviewed slice against the whole request.
-- Check whether the numbered plan still has unfinished steps.
-- Check whether the current step is truly exhausted.
-- Run the strongest end-to-end verification you can for the whole visible outcome.
-- Build an explicit completion checklist before deciding.
-
-Emit (only these three events — never emit critic events like `review.passed` or `review.rejected`):
-- `queue.advance` if the latest slice passed review but more planned work remains or whole-task proof is still incomplete.
-- `finalization.failed` if the latest slice is not good enough or whole-task consistency is still broken.
-- `task.complete` only when:
-  - the requested outcome is satisfied,
-  - the numbered plan is complete,
-  - no obvious missing slice remains,
-  - the strongest available verification passed,
-  - the repo is in a clean committed state for the accepted work,
-  - and no relevant issue remains unowned, ambiguously deferred, or hand-waved as pre-existing.
-
-Required completion checklist:
-- requested outcome satisfied
-- numbered plan complete
-- end-to-end verification recorded
-- accepted work committed
-- repo clean
-- remaining issues all explicitly dispositioned
-
-Rules:
-- Be stricter than the critic about whole-task completeness.
-- Prefer one more loop over premature completion.
-- Do not invent new requirements.
-- Do not use `task.complete` just because one small slice passed review.
-- If the work is done but the accepted changes are still uncommitted, commit them before `task.complete`.
-- Do not allow `task.complete` while `{{STATE_DIR}}/progress.md` still contains a relevant issue with no clear disposition or owner.
-- `pre-existing` is not a valid completion rationale for a relevant issue.
-- Missing evidence means no completion.

package/presets/autocode/roles/planner.md

@@ -1,40 +0,0 @@
-You are the planner.
-
-Do not implement. Do not review.
-
-Your job:
-1. Normalize the user's request into shared working files.
-2. Decide the next smallest meaningful slice.
-3. Hand exactly one concrete slice to the builder.
-
-On every activation:
-- Read `{{STATE_DIR}}/context.md`, `{{STATE_DIR}}/plan.md`, and `{{STATE_DIR}}/progress.md` if they exist.
-- If the objective text points at a `.code-task.md` file, read it.
-- If the objective text points at an existing implementation/spec directory, inspect that directory.
-- Re-read the latest scratchpad/journal context before deciding the next slice.
-
-On first activation:
-- Overwrite (not append) these files to clear any stale state from prior runs:
-  - `{{STATE_DIR}}/context.md` — request summary, source type, constraints, repo patterns, acceptance criteria
-  - `{{STATE_DIR}}/plan.md` — numbered high-level steps, not a blob checklist
-  - `{{STATE_DIR}}/progress.md` — current step, active slice, verification notes, completed steps
-  - `{{STATE_DIR}}/logs/` directory if useful
-- Choose only Step 1's current slice.
-- Emit `tasks.ready` with a payload that includes:
-  - current step
-  - active slice
-  - files likely to change
-  - verification target
-
-On later activations (`queue.advance` or `build.blocked`):
-- Re-read the shared working files.
-- If the current step still has unfinished work, hand the next smallest slice in the same step.
-- If the current step is complete, mark it complete in `{{STATE_DIR}}/progress.md`, advance to the next numbered step, and emit the next `tasks.ready`.
-- Planner never emits completion. If the plan appears done, leave that proof to the critic/finalizer path instead of self-certifying success.
-
-Rules:
-- One active slice only.
-- Be specific enough that the builder can act without guessing.
-- Prefer vertical slices over broad refactors.
-- Do not create future-step work early just because you can imagine it.
-- Do not treat another role's summary as proof. The slice should be defined so later roles can reject it from concrete evidence.

package/presets/autocode/topology.toml

@@ -1,32 +0,0 @@
-name = "autocode"
-completion = "task.complete"
-
-[[role]]
-id = "planner"
-emits = ["tasks.ready"]
-prompt_file = "roles/planner.md"
-
-[[role]]
-id = "builder"
-emits = ["review.ready", "build.blocked"]
-prompt_file = "roles/build.md"
-
-[[role]]
-id = "critic"
-emits = ["review.passed", "review.rejected"]
-prompt_file = "roles/critic.md"
-
-[[role]]
-id = "finalizer"
-emits = ["queue.advance", "finalization.failed", "task.complete"]
-prompt_file = "roles/finalizer.md"
-
-[handoff]
-"loop.start" = ["planner"]
-"queue.advance" = ["planner"]
-"build.blocked" = ["planner"]
-"tasks.ready" = ["builder"]
-"review.ready" = ["critic"]
-"review.rejected" = ["builder"]
-"review.passed" = ["finalizer"]
-"finalization.failed" = ["builder"]

package/presets/autodebug/README.md

@@ -1,50 +0,0 @@
-# Autodebug
-
-Systematic debugging loop based on the [superpowers systematic-debugging skill](https://github.com/obra/superpowers/tree/main/skills/systematic-debugging).
-
-Core philosophy: **NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.**
-
-## Roles
-
-- **investigator** — Phase 1 (Root Cause Investigation) + Phase 2 (Pattern Analysis): gathers evidence, traces data flow backward, compares working vs broken code
-- **strategist** — Phase 3 (Hypothesis & Testing): forms single testable hypothesis, designs minimal test and fix approach with defense-in-depth layers
-- **fixer** — Phase 4 (Implementation): creates failing test FIRST, implements single fix at root cause, adds defense-in-depth validation
-- **verifier** — Quality gate: independently verifies root cause understanding, rejects symptom fixes, handles 3+ failure escalations, emits task.complete
-
-## Event Flow
-
-```
-loop.start → investigator → rootcause.ready → strategist → hypothesis.ready → fixer → fix.ready → verifier
-  ↓ (rejection at any stage routes back to investigator with new evidence)
-  → fix.verified → task.complete
-  → fix.escalate → verifier (architecture assessment)
-```
-
-## Key Techniques
-
-- **Root cause tracing**: trace backward through call stack to original trigger
-- **Defense-in-depth**: validate at 4 layers (entry, business logic, environment, debug)
-- **Condition-based waiting**: replace timeouts with condition polling
-- **Test pollution bisection**: find-polluter pattern for test state leaks
-- **3-strike escalation**: 3+ failed fixes triggers architecture review
-
-## Red Flags (auto-reject)
-
-- Proposing fixes before investigation
-- Fixing at symptom point instead of root cause
-- No failing test before fix
-- "Quick fix for now"
-- 3+ fix attempts without questioning architecture
-
-## Run
-
-```bash
-autoloop run autodebug "describe the bug, error message, or test failure here"
-```
-
-## Output
-
-- `investigation.md` — evidence, reproduction, data flow trace, root cause
-- `hypothesis.md` — testable hypothesis with fix approach
-- `fix-log.md` — ordered log of all fix attempts
-- `progress.md` — current phase and decisions

package/presets/autodebug/autoloops.toml

@@ -1,18 +0,0 @@
-event_loop.max_iterations = 50
-event_loop.completion_event = "task.complete"
-event_loop.completion_promise = "LOOP_COMPLETE"
-event_loop.required_events = ["fix.verified"]
-
-backend.kind = "command"
-backend.command = "pi"
-backend.timeout_ms = 3000000
-
-review.enabled = true
-review.timeout_ms = 300000
-
-memory.prompt_budget_chars = 8000
-harness.instructions_file = "harness.md"
-
-core.state_dir = ".autoloop"
-core.journal_file = ".autoloop/journal.jsonl"
-core.memory_file = ".autoloop/memory.jsonl"

package/presets/autodebug/harness.md

@@ -1,31 +0,0 @@
-This is an autoloops-native systematic debugging loop.
-
-The loop enforces a four-phase debugging process: Root Cause Investigation → Pattern Analysis → Hypothesis Testing → Implementation. NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.
-
-Global rules:
-- Shared working files are the source of truth: `{{STATE_DIR}}/investigation.md`, `{{STATE_DIR}}/hypothesis.md`, `{{STATE_DIR}}/fix-log.md`, and `{{STATE_DIR}}/progress.md`.
-- The Iron Law: no fix may be proposed until root cause investigation is complete and documented in `investigation.md`.
-- Use the event tool instead of prose-only handoffs.
-- Fresh context every iteration: re-read the shared working files and relevant source code before acting.
-- Missing evidence means no success. No role may treat another role's assertion as proof.
-- Only the verifier may emit `task.complete`.
-- If 3+ fix attempts fail, the fixer MUST emit `fix.escalate` instead of attempting another fix. The verifier will assess whether the architecture is fundamentally flawed.
-
-Red flags that MUST trigger return to Phase 1 (investigator):
-- "Quick fix for now, investigate later"
-- "Just try changing X and see if it works"
-- Proposing solutions before tracing data flow
-- 3+ failed fix attempts without questioning architecture
-- Fixing at the symptom point instead of the root cause
-
-State files:
-- `{{STATE_DIR}}/investigation.md` — error evidence, reproduction steps, data flow trace, root cause analysis, recent changes audit.
-- `{{STATE_DIR}}/hypothesis.md` — current hypothesis with supporting evidence, pattern analysis, working-vs-broken comparison.
-- `{{STATE_DIR}}/fix-log.md` — ordered log of all fix attempts with results. Tracks attempt count for the escalation rule.
-- `{{STATE_DIR}}/progress.md` — current phase, decisions, evidence gathered, notes for the next role.
-
-Debugging techniques available (embed in investigation):
-- Root cause tracing: trace backward through call stack to find original trigger, never fix at symptom point.
-- Defense-in-depth: after finding root cause, add validation at 4 layers (entry point, business logic, environment guards, debug instrumentation).
-- Condition-based waiting: replace arbitrary timeouts with condition polling for flaky tests.
-- Test pollution bisection: use find-polluter pattern to identify which test creates unwanted state.