@mobrienv/autoloop 0.3.0 → 0.7.0

package/dist/dashboard/views/shell.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shell.js","sourceRoot":"","sources":["../../../src/dashboard/views/shell.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS;IACvB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsuBD,CAAC;AACT,CAAC"}

package/dist/events/decode.d.ts

@@ -1,2 +0,0 @@
-import type { JournalEvent } from "./types.js";
-export declare function decodeEvent(line: string): JournalEvent | null;

package/dist/events/decode.js

@@ -1,45 +0,0 @@
-export function decodeEvent(line) {
-    if (!line.trim())
-        return null;
-    try {
-        const parsed = JSON.parse(line);
-        const run = typeof parsed.run === "string" ? parsed.run : "";
-        const topic = typeof parsed.topic === "string" ? parsed.topic : "";
-        const iteration = typeof parsed.iteration === "string" ? parsed.iteration : undefined;
-        if (typeof parsed.payload === "string") {
-            const event = {
-                shape: "payload",
-                run,
-                topic,
-                payload: parsed.payload,
-            };
-            if (iteration)
-                event.iteration = iteration;
-            if (typeof parsed.source === "string")
-                event.source = parsed.source;
-            return event;
-        }
-        const rawFields = isObject(parsed.fields) ? parsed.fields : {};
-        const fields = {};
-        for (const [key, value] of Object.entries(rawFields)) {
-            fields[key] = value === null || value === undefined ? "" : String(value);
-        }
-        const event = {
-            shape: "fields",
-            run,
-            topic,
-            fields,
-            rawFields,
-        };
-        if (iteration)
-            event.iteration = iteration;
-        return event;
-    }
-    catch {
-        return null;
-    }
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//# sourceMappingURL=decode.js.map

package/dist/events/decode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/events/decode.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;QAAE,OAAO,IAAI,CAAC;IAC9B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAA4B,CAAC;QAC3D,MAAM,GAAG,GAAG,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7D,MAAM,KAAK,GAAG,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QACnE,MAAM,SAAS,GACb,OAAO,MAAM,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;QAEtE,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YACvC,MAAM,KAAK,GAAiB;gBAC1B,KAAK,EAAE,SAAS;gBAChB,GAAG;gBACH,KAAK;gBACL,OAAO,EAAE,MAAM,CAAC,OAAO;aACxB,CAAC;YACF,IAAI,SAAS;gBAAE,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3C,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ;gBAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YACpE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/D,MAAM,MAAM,GAA2B,EAAE,CAAC;QAC1C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YACrD,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3E,CAAC;QACD,MAAM,KAAK,GAAgB;YACzB,KAAK,EAAE,QAAQ;YACf,GAAG;YACH,KAAK;YACL,MAAM;YACN,SAAS;SACV,CAAC;QACF,IAAI,SAAS;YAAE,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3C,OAAO,KAAK,CAAC;IACf,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC"}

package/dist/events/encode.d.ts

@@ -1,2 +0,0 @@
-import type { JournalEvent } from "./types.js";
-export declare function encodeEvent(event: JournalEvent): string;

package/dist/events/encode.js

@@ -1,33 +0,0 @@
-import { jsonBool, jsonField, jsonFieldRaw } from "../json.js";
-export function encodeEvent(event) {
-    const base = [jsonField("run", event.run)];
-    if (event.iteration)
-        base.push(jsonField("iteration", event.iteration));
-    base.push(jsonField("topic", String(event.topic)));
-    if (event.shape === "payload") {
-        base.push(jsonField("payload", event.payload));
-        if (event.source)
-            base.push(jsonField("source", event.source));
-        return `{${base.join(", ")}}\n`;
-    }
-    return ("{" +
-        base.join(", ") +
-        ', "fields": {' +
-        encodeFields(event.rawFields ?? event.fields) +
-        "}}\n");
-}
-function encodeFields(fields) {
-    return Object.entries(fields)
-        .map(([key, value]) => encodeField(key, value))
-        .join(", ");
-}
-function encodeField(key, value) {
-    if (typeof value === "boolean")
-        return jsonFieldRaw(key, jsonBool(value));
-    if (typeof value === "number")
-        return jsonFieldRaw(key, String(value));
-    if (value === null)
-        return jsonFieldRaw(key, "null");
-    return jsonField(key, String(value ?? ""));
-}
-//# sourceMappingURL=encode.js.map

package/dist/events/encode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/events/encode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/D,MAAM,UAAU,WAAW,CAAC,KAAmB;IAC7C,MAAM,IAAI,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3C,IAAI,KAAK,CAAC,SAAS;QAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IACxE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAEnD,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC9B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAC/C,IAAI,KAAK,CAAC,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QAC/D,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;IAClC,CAAC;IAED,OAAO,CACL,GAAG;QACH,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;QACf,eAAe;QACf,YAAY,CAAC,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,CAAC;QAC7C,MAAM,CACP,CAAC;AACJ,CAAC;AAED,SAAS,YAAY,CAAC,MAA+B;IACnD,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;SAC1B,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;SAC9C,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAED,SAAS,WAAW,CAAC,GAAW,EAAE,KAAc;IAC9C,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1E,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACvE,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACrD,OAAO,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC;AAC7C,CAAC"}

package/dist/events/guards.d.ts

@@ -1,5 +0,0 @@
-import type { JournalEvent } from "./types.js";
-export declare function isPayloadEvent(event: JournalEvent | null): boolean;
-export declare function isSystemEvent(event: JournalEvent | null): boolean;
-export declare function isCoordinationEvent(event: JournalEvent | null): boolean;
-export declare function isRoutingEvent(event: JournalEvent | null): boolean;

package/dist/events/guards.js

@@ -1,42 +0,0 @@
-const SYSTEM_TOPICS = new Set([
-    "iteration.start",
-    "iteration.finish",
-    "loop.start",
-    "loop.complete",
-    "loop.stop",
-    "review.start",
-    "review.finish",
-    "backend.start",
-    "backend.finish",
-    "event.invalid",
-]);
-const COORDINATION_TOPICS = new Set([
-    "issue.discovered",
-    "issue.resolved",
-    "slice.started",
-    "slice.verified",
-    "slice.committed",
-    "context.archived",
-    "chain.spawn",
-]);
-export function isPayloadEvent(event) {
-    return !!event && event.shape === "payload";
-}
-export function isSystemEvent(event) {
-    if (!event)
-        return false;
-    if (SYSTEM_TOPICS.has(String(event.topic)))
-        return true;
-    return String(event.topic).startsWith("wave.");
-}
-export function isCoordinationEvent(event) {
-    return !!event && COORDINATION_TOPICS.has(String(event.topic));
-}
-export function isRoutingEvent(event) {
-    if (!event)
-        return false;
-    if (isCoordinationEvent(event) || isSystemEvent(event))
-        return false;
-    return String(event.topic) !== "";
-}
-//# sourceMappingURL=guards.js.map

package/dist/events/guards.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/events/guards.ts"],"names":[],"mappings":"AAEA,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC;IAC5B,iBAAiB;IACjB,kBAAkB;IAClB,YAAY;IACZ,eAAe;IACf,WAAW;IACX,cAAc;IACd,eAAe;IACf,eAAe;IACf,gBAAgB;IAChB,eAAe;CAChB,CAAC,CAAC;AAEH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IAClC,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,gBAAgB;IAChB,iBAAiB;IACjB,kBAAkB;IAClB,aAAa;CACd,CAAC,CAAC;AAEH,MAAM,UAAU,cAAc,CAAC,KAA0B;IACvD,OAAO,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,KAA0B;IACtD,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,IAAI,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACxD,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,KAA0B;IAC5D,OAAO,CAAC,CAAC,KAAK,IAAI,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AACjE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,KAA0B;IACvD,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,IAAI,mBAAmB,CAAC,KAAK,CAAC,IAAI,aAAa,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrE,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;AACpC,CAAC"}

package/dist/events/types.d.ts

@@ -1,26 +0,0 @@
-export type LoopTopic = "loop.start" | "loop.complete" | "loop.stop";
-export type IterationTopic = "iteration.start" | "iteration.finish";
-export type BackendTopic = "backend.start" | "backend.finish";
-export type ReviewTopic = "review.start" | "review.finish";
-export type CoordinationTopic = "issue.discovered" | "issue.resolved" | "slice.started" | "slice.verified" | "slice.committed" | "context.archived" | "chain.spawn";
-export type ChainTopic = "chain.start" | "chain.complete";
-export type OperatorTopic = "operator.guidance" | "operator.guidance.consumed";
-export type WaveTopic = string;
-export type CoreSystemTopic = LoopTopic | IterationTopic | BackendTopic | ReviewTopic | "event.invalid";
-export type KnownTopic = CoreSystemTopic | CoordinationTopic | ChainTopic | OperatorTopic | WaveTopic | string;
-export interface EventBase {
-    run: string;
-    topic: KnownTopic;
-    iteration?: string;
-}
-export interface FieldsEvent extends EventBase {
-    shape: "fields";
-    fields: Record<string, string>;
-    rawFields?: Record<string, unknown>;
-}
-export interface PayloadEvent extends EventBase {
-    shape: "payload";
-    payload: string;
-    source?: string;
-}
-export type JournalEvent = FieldsEvent | PayloadEvent;

package/dist/events/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/events/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/events/types.ts"],"names":[],"mappings":""}

package/dist/harness/config-helpers.d.ts

@@ -1,35 +0,0 @@
-import * as config from "../config.js";
-import * as topo from "../topology.js";
-import type { LoopContext, RunOptions } from "./types.js";
-export declare function resolvePrompt(projectDir: string, cfg: config.Config, override: string | null): string;
-export declare function resolveReviewPrompt(projectDir: string, cfg: config.Config): string;
-export declare function readOptionalProjectFile(projectDir: string, relativePath: string): string;
-export declare function resolveReviewEvery(cfg: config.Config, topoData: topo.Topology): number;
-export declare function truthySetting(value: string): boolean;
-export declare function ensureLayout(stateDir: string): void;
-export declare function installRuntimeTools(loop: LoopContext): void;
-export declare function resolveProcessKind(kind: string, command: string): string;
-export declare function normalizePromptMode(value: string): string;
-export declare function configListWithFallback(cfg: config.Config, key: string, fallback: string[]): string[];
-export declare function injectClaudePermissions(command: string, args: string[]): string[];
-export declare function processStringOverride(override: Record<string, unknown>, key: string, fallback: string): string;
-export declare function processListOverride(override: Record<string, unknown>, key: string, fallback: string[]): string[];
-export declare function claudeBackend(command: string): boolean;
-export declare function nextRunId(path: string, cfg: config.Config): string;
-export declare function iterationFieldForRun(journalFile: string, runId: string, iteration: string, topic: string, field: string): string;
-export declare function ensureRenderRunId(journalFile: string): string;
-export declare function absolutePath(path: string): string;
-export declare function emptyFallback(text: string): string;
-/**
- * Resolve the journal file path for a specific run.
- * Delegates to resolveRunJournalPath for run-scoped/worktree paths,
- * falling back to the top-level journal.
- */
-export declare function resolveJournalFileForRun(projectDir: string, runId: string): {
-    journalFile: string;
-    runId: string;
-};
-export declare function buildLoopContext(projectDir: string, promptOverride: string | null, selfCommand: string, runOptions: RunOptions): LoopContext;
-export declare function reloadLoop(loop: LoopContext): LoopContext;
-export declare function applyRuntimeModeOverrides(loop: LoopContext): LoopContext;
-export declare function initStore(loop: LoopContext): LoopContext;

package/dist/harness/config-helpers.js

@@ -1,411 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { basename, join, resolve } from "node:path";
-import { loadAgentMap } from "../agent-map.js";
-import * as config from "../config.js";
-import { presetCategory, resolveIsolationMode } from "../isolation/resolve.js";
-import { createRunScopedDir } from "../isolation/run-scope.js";
-import * as profiles from "../profiles.js";
-import { activeRuns } from "../registry/read.js";
-import * as topo from "../topology.js";
-import { assertNoRawAutoloopPaths, expandTemplatePlaceholders, generateCompactId, generateReadableId, splitCsv, uniqueGeneratedId, } from "../utils.js";
-import { createWorktree } from "../worktree/create.js";
-import { extractField, extractIteration, extractTopic, latestRunId, readLines, readRunLines, resolveRunJournalPath, } from "./journal.js";
-import { emitToolScript, piAdapterScript } from "./tools.js";
-export function resolvePrompt(projectDir, cfg, override) {
-    if (override !== null)
-        return override;
-    const inlinePrompt = config.get(cfg, "event_loop.prompt", "");
-    if (inlinePrompt)
-        return inlinePrompt;
-    const promptFile = config.get(cfg, "event_loop.prompt_file", "");
-    if (promptFile) {
-        const fullPath = join(projectDir, promptFile);
-        if (existsSync(fullPath))
-            return readFileSync(fullPath, "utf-8");
-    }
-    return "Do the task and publish the completion event when finished.";
-}
-export function resolveReviewPrompt(projectDir, cfg) {
-    const inlinePrompt = config.get(cfg, "review.prompt", "");
-    if (inlinePrompt)
-        return inlinePrompt;
-    return readOptionalProjectFile(projectDir, config.get(cfg, "review.prompt_file", "metareview.md"));
-}
-export function readOptionalProjectFile(projectDir, relativePath) {
-    if (!relativePath)
-        return "";
-    const fullPath = join(projectDir, relativePath);
-    if (!existsSync(fullPath))
-        return "";
-    return readFileSync(fullPath, "utf-8");
-}
-export function resolveReviewEvery(cfg, topoData) {
-    const configured = config.getInt(cfg, "review.every_iterations", 0);
-    if (configured > 0)
-        return configured;
-    const count = topo.roleCount(topoData);
-    return count > 0 ? count : 1;
-}
-export function truthySetting(value) {
-    return value !== "false" && value !== "0" && value !== "";
-}
-export function ensureLayout(stateDir) {
-    mkdirSync(stateDir, { recursive: true });
-}
-export function installRuntimeTools(loop) {
-    writeFileSync(loop.paths.toolPath, emitToolScript(loop));
-    chmodSync(loop.paths.toolPath, 0o755);
-    writeFileSync(loop.paths.piAdapterPath, piAdapterScript(loop));
-    chmodSync(loop.paths.piAdapterPath, 0o755);
-}
-export function resolveProcessKind(kind, command) {
-    if (kind === "pi")
-        return "pi";
-    if (kind === "kiro")
-        return "kiro";
-    if (kind === "command")
-        return "command";
-    return piBinary(command) ? "pi" : "command";
-}
-function piBinary(command) {
-    return command === "pi" || command.endsWith("/pi");
-}
-export function normalizePromptMode(value) {
-    return value === "stdin" ? "stdin" : "arg";
-}
-export function configListWithFallback(cfg, key, fallback) {
-    const marker = "__missing__";
-    const raw = config.get(cfg, key, marker);
-    if (raw === marker)
-        return fallback;
-    return splitCsv(raw);
-}
-export function injectClaudePermissions(command, args) {
-    if (!claudeBackend(command))
-        return args;
-    const injected = [...args];
-    if (!injected.includes("-p"))
-        injected.unshift("-p");
-    if (!injected.includes("--dangerously-skip-permissions")) {
-        injected.push("--dangerously-skip-permissions");
-    }
-    return injected;
-}
-export function processStringOverride(override, key, fallback) {
-    const val = override[key];
-    return typeof val === "string" ? val : fallback;
-}
-export function processListOverride(override, key, fallback) {
-    const val = override[key];
-    return Array.isArray(val) ? val : fallback;
-}
-export function claudeBackend(command) {
-    return command === "claude" || command.endsWith("/claude");
-}
-export function nextRunId(path, cfg) {
-    const lines = readLines(path);
-    const format = config.get(cfg, "core.run_id_format", "human");
-    if (format === "counter") {
-        const count = lines.filter((l) => extractTopic(l) === "loop.start").length;
-        return `run-${count + 1}`;
-    }
-    const existing = new Set(lines.map((line) => extractField(line, "run")).filter(Boolean));
-    if (format === "compact") {
-        return (uniqueGeneratedId(() => generateCompactId("run"), existing) ??
-            generateCompactId("run"));
-    }
-    return (uniqueGeneratedId(generateReadableId, existing) ?? generateCompactId("run"));
-}
-export function iterationFieldForRun(journalFile, runId, iteration, topic, field) {
-    const lines = readRunLines(journalFile, runId);
-    let current = "";
-    for (const line of lines) {
-        if (extractTopic(line) === topic && extractIteration(line) === iteration) {
-            current = extractField(line, field);
-        }
-    }
-    return current;
-}
-export function ensureRenderRunId(journalFile) {
-    return process.env.AUTOLOOP_RUN_ID || latestRunId(journalFile);
-}
-export function absolutePath(path) {
-    if (path.startsWith("/"))
-        return path;
-    return resolve(process.cwd(), path);
-}
-export function emptyFallback(text) {
-    return text || "(empty)";
-}
-/**
- * Resolve the journal file path for a specific run.
- * Delegates to resolveRunJournalPath for run-scoped/worktree paths,
- * falling back to the top-level journal.
- */
-export function resolveJournalFileForRun(projectDir, runId) {
-    const stateDir = config.stateDirPath(projectDir);
-    const resolved = resolveRunJournalPath(stateDir, runId);
-    const journalFile = resolved ?? config.resolveJournalFile(projectDir);
-    return { journalFile, runId };
-}
-export function buildLoopContext(projectDir, promptOverride, selfCommand, runOptions) {
-    const resolvedProjectDir = absolutePath(projectDir);
-    const resolvedWorkDir = absolutePath(runOptions.workDir || ".");
-    const cfg = config.loadProject(resolvedProjectDir);
-    const stateDir = join(resolvedWorkDir, config.get(cfg, "core.state_dir", ".miniloop"));
-    const journalFile = config.resolveJournalFileIn(resolvedProjectDir, resolvedWorkDir);
-    const memoryFile = config.resolveMemoryFileIn(resolvedProjectDir, resolvedWorkDir);
-    // tasksFile is resolved later, after isolation mode determines effectiveStateDir
-    const runId = nextRunId(journalFile, cfg);
-    const backendOverride = runOptions.backendOverride || {};
-    const logLevel = runOptions.logLevel || config.get(cfg, "core.log_level", "info");
-    // Resolve isolation mode
-    const registryFile = join(stateDir, "registry.jsonl");
-    const otherActive = activeRuns(registryFile);
-    const configIsolationEnabled = config.get(cfg, "worktree.enabled", "") === "true" ||
-        config.get(cfg, "isolation.enabled", "false") === "true";
-    const currentPresetName = basename(resolvedProjectDir);
-    const currentCat = presetCategory(currentPresetName, resolvedProjectDir);
-    const isolation = resolveIsolationMode({
-        worktree: runOptions.worktree,
-        noWorktree: runOptions.noWorktree,
-        configEnabled: configIsolationEnabled,
-        currentCategory: currentCat,
-    }, otherActive);
-    if (isolation.warning) {
-        process.stderr.write(`\n${isolation.warning}\n\n`);
-    }
-    // For run-scoped isolation, route per-run state files to runs/<runId>/
-    let effectiveStateDir = isolation.mode === "run-scoped"
-        ? createRunScopedDir(stateDir, runId)
-        : stateDir;
-    // Worktree mode: create git worktree and redirect workDir + stateDir
-    let effectiveWorkDir = resolvedWorkDir;
-    let worktreeBranch = "";
-    let worktreePath = "";
-    let worktreeMetaDir = "";
-    if (isolation.mode === "worktree") {
-        const branchPrefix = config.get(cfg, "worktree.branch_prefix", "autoloop");
-        const mergeStrategy = runOptions.mergeStrategy ||
-            config.get(cfg, "worktree.merge_strategy", "squash");
-        const wt = createWorktree({
-            mainProjectDir: resolvedProjectDir,
-            mainStateDir: stateDir,
-            runId,
-            branchPrefix,
-            mergeStrategy,
-        });
-        effectiveWorkDir = wt.worktreePath;
-        worktreeBranch = wt.branch;
-        worktreePath = wt.worktreePath;
-        worktreeMetaDir = wt.metaDir;
-        effectiveStateDir = join(wt.worktreePath, config.get(cfg, "core.state_dir", ".miniloop"));
-    }
-    // Compute active profiles: config defaults (unless suppressed) + CLI explicit
-    const cliProfiles = runOptions.profiles ?? [];
-    const noDefaults = runOptions.noDefaultProfiles ?? false;
-    const configDefaults = noDefaults ? [] : config.getProfileDefaults(cfg);
-    const activeProfiles = [...configDefaults, ...cliProfiles];
-    // Tasks are always per-run: use effectiveStateDir (already per-run for
-    // run-scoped/worktree), or route to runs/<runId>/ for shared mode.
-    const tasksFile = isolation.mode === "run-scoped" || isolation.mode === "worktree"
-        ? join(effectiveStateDir, "tasks.jsonl")
-        : join(stateDir, "runs", runId, "tasks.jsonl");
-    // Only paths, runtime, launch, profiles, and store survive — reloadLoop fills the rest from config.
-    const seed = {
-        paths: {
-            projectDir: resolvedProjectDir,
-            workDir: effectiveWorkDir,
-            stateDir: effectiveStateDir,
-            journalFile: isolation.mode === "worktree"
-                ? join(effectiveStateDir, "journal.jsonl")
-                : journalFile,
-            memoryFile,
-            tasksFile,
-            registryFile,
-            toolPath: join(effectiveStateDir, "autoloops"),
-            piAdapterPath: join(effectiveStateDir, "pi-adapter"),
-            baseStateDir: stateDir,
-            mainProjectDir: resolvedProjectDir,
-            worktreeBranch,
-            worktreePath,
-            worktreeMetaDir,
-        },
-        runtime: {
-            runId,
-            selfCommand,
-            promptOverride: promptOverride ?? null,
-            backendOverride,
-            logLevel,
-            branchMode: false,
-            isolationMode: isolation.mode,
-        },
-        launch: {
-            preset: basename(resolvedProjectDir),
-            trigger: runOptions.trigger ?? "cli",
-            createdAt: new Date().toISOString(),
-            parentRunId: runOptions.parentRunId ?? "",
-        },
-        profiles: {
-            active: activeProfiles,
-            fragments: new Map(),
-            warnings: [],
-        },
-        store: {},
-    };
-    return reloadLoop(seed);
-}
-export function reloadLoop(loop) {
-    const pd = loop.paths.projectDir;
-    const wd = loop.paths.workDir;
-    const cfg = config.loadProject(pd);
-    const topoData = topo.loadTopology(pd);
-    const backend = readBackendConfig(cfg, loop.runtime.backendOverride);
-    const review = readReviewConfig(cfg, topoData, pd, backend);
-    const parallel = readParallelConfig(cfg);
-    // Resolve and apply profile fragments
-    const activeProfiles = loop.profiles?.active ?? [];
-    let profileInfo = loop.profiles ?? {
-        active: [],
-        fragments: new Map(),
-        warnings: [],
-    };
-    let finalTopology = topoData;
-    if (activeProfiles.length > 0) {
-        const presetName = loop.launch.preset;
-        const resolved = profiles.resolveProfileFragments(activeProfiles, presetName, topoData.roles, wd);
-        profileInfo = {
-            active: activeProfiles,
-            fragments: resolved.fragments,
-            warnings: resolved.warnings,
-        };
-        finalTopology = {
-            ...topoData,
-            roles: profiles.applyProfileFragments(topoData.roles, resolved.fragments),
-        };
-        for (const w of resolved.warnings) {
-            process.stderr.write(`profile warning: ${w}\n`);
-        }
-    }
-    const templateVars = {
-        STATE_DIR: loop.paths.stateDir,
-        TOOL_PATH: loop.paths.toolPath,
-    };
-    const updatedTopology = {
-        ...finalTopology,
-        roles: finalTopology.roles.map((role) => {
-            const prompt = expandTemplatePlaceholders(role.prompt, templateVars);
-            assertNoRawAutoloopPaths(prompt, `role prompt: ${role.id}`);
-            return { ...role, prompt };
-        }),
-    };
-    const updated = {
-        objective: resolvePrompt(pd, cfg, loop.runtime.promptOverride),
-        topology: updatedTopology,
-        limits: {
-            maxIterations: config.getInt(cfg, "event_loop.max_iterations", 3),
-        },
-        completion: {
-            promise: config.get(cfg, "event_loop.completion_promise", "LOOP_COMPLETE"),
-            event: topo.completionEvent(topoData, config.get(cfg, "event_loop.completion_event", "task.complete")),
-            requiredEvents: config.getList(cfg, "event_loop.required_events"),
-        },
-        backend,
-        review: {
-            ...review,
-            prompt: (() => {
-                const p = expandTemplatePlaceholders(review.prompt, templateVars);
-                assertNoRawAutoloopPaths(p, "metareview prompt");
-                return p;
-            })(),
-        },
-        parallel,
-        memory: {
-            budgetChars: config.getInt(cfg, "memory.prompt_budget_chars", 8000),
-        },
-        tasks: {
-            budgetChars: config.getInt(cfg, "tasks.prompt_budget_chars", 4000),
-        },
-        harness: {
-            instructions: (() => {
-                const raw = readOptionalProjectFile(pd, config.get(cfg, "harness.instructions_file", "harness.md"));
-                const expanded = expandTemplatePlaceholders(raw, templateVars);
-                assertNoRawAutoloopPaths(expanded, "harness instructions");
-                return expanded;
-            })(),
-        },
-        profiles: profileInfo,
-        paths: loop.paths,
-        runtime: loop.runtime,
-        launch: loop.launch,
-        store: {
-            ...loop.store,
-            ...(backend.kind === "kiro"
-                ? {
-                    kiro_trust_all_tools: config.get(cfg, "backend.trust_all_tools", "true") !== "false",
-                    kiro_agent: config.get(cfg, "backend.agent", ""),
-                    kiro_model: config.get(cfg, "backend.model", ""),
-                }
-                : {}),
-        },
-        agentMap: loadAgentMap(pd),
-    };
-    return applyRuntimeModeOverrides(updated);
-}
-function readBackendConfig(cfg, bo) {
-    const command = processStringOverride(bo, "command", config.get(cfg, "backend.command", "pi"));
-    const kind = resolveProcessKind(processStringOverride(bo, "kind", config.get(cfg, "backend.kind", "")), command);
-    const args = injectClaudePermissions(command, processListOverride(bo, "args", configListWithFallback(cfg, "backend.args", [])));
-    const promptMode = normalizePromptMode(processStringOverride(bo, "prompt_mode", config.get(cfg, "backend.prompt_mode", "arg")));
-    const timeoutMs = config.getInt(cfg, "backend.timeout_ms", 300000);
-    return { kind, command, args, promptMode, timeoutMs };
-}
-function readReviewConfig(cfg, topoData, projectDir, backend) {
-    const command = config.get(cfg, "review.command", backend.command);
-    const kind = resolveProcessKind(config.get(cfg, "review.kind", backend.kind), command);
-    return {
-        enabled: truthySetting(config.get(cfg, "review.enabled", "true")),
-        every: resolveReviewEvery(cfg, topoData),
-        kind,
-        command,
-        args: configListWithFallback(cfg, "review.args", backend.args),
-        promptMode: normalizePromptMode(config.get(cfg, "review.prompt_mode", backend.promptMode)),
-        prompt: resolveReviewPrompt(projectDir, cfg),
-        timeoutMs: config.getInt(cfg, "review.timeout_ms", 300000),
-    };
-}
-function readParallelConfig(cfg) {
-    return {
-        enabled: truthySetting(config.get(cfg, "parallel.enabled", "false")),
-        maxBranches: config.getInt(cfg, "parallel.max_branches", 3),
-        branchTimeoutMs: config.getInt(cfg, "parallel.branch_timeout_ms", 180000),
-    };
-}
-export function applyRuntimeModeOverrides(loop) {
-    if (!loop.runtime.branchMode)
-        return loop;
-    return {
-        ...loop,
-        limits: { maxIterations: 1 },
-        review: { ...loop.review, enabled: false },
-        parallel: { ...loop.parallel, enabled: false },
-        backend: {
-            ...loop.backend,
-            timeoutMs: Math.min(loop.backend.timeoutMs, loop.parallel.branchTimeoutMs),
-        },
-    };
-}
-export function initStore(loop) {
-    return {
-        ...loop,
-        store: {
-            run_id: loop.runtime.runId,
-            project_dir: loop.paths.projectDir,
-            self_command: loop.runtime.selfCommand,
-            max_iterations: loop.limits.maxIterations,
-            completion_event: loop.completion.event,
-            completion_promise: loop.completion.promise,
-        },
-    };
-}
-//# sourceMappingURL=config-helpers.js.map