@lsctech/polaris 0.3.28 → 0.4.0

package/dist/cli/setup-interview/runner.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInterview = runInterview;
+const promises_1 = require("node:readline/promises");
+const store_js_1 = require("./store.js");
+const QUESTION_BANK = [
+    {
+        key: "project_purpose",
+        prompt: "What is the purpose of this project? (one sentence)",
+        parse: (raw) => raw.trim(),
+    },
+    {
+        key: "source_roots",
+        prompt: "Source root directories (comma-separated, e.g. src,lib):",
+        parse: (raw) => splitCsv(raw),
+    },
+    {
+        key: "languages",
+        prompt: "Primary languages/frameworks (comma-separated, e.g. typescript,react):",
+        parse: (raw) => splitCsv(raw),
+    },
+    {
+        key: "canonical_doc_folders",
+        prompt: "Canonical documentation folders (comma-separated, e.g. docs,smartdocs):",
+        parse: (raw) => splitCsv(raw),
+    },
+    {
+        key: "never_touch",
+        prompt: "Paths agents should never modify (comma-separated, or leave blank):",
+        parse: (raw) => splitCsv(raw),
+    },
+    {
+        key: "providers_by_role",
+        prompt: "Agent providers by role — format: role:provider,role:provider (or leave blank):",
+        parse: parseProvidersByRole,
+    },
+];
+function splitCsv(raw) {
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function parseProvidersByRole(raw) {
+    const result = {};
+    for (const pair of raw.split(",")) {
+        const [role, provider] = pair.split(":").map((s) => s.trim());
+        if (role && provider) {
+            result[role] = provider;
+        }
+    }
+    return result;
+}
+/**
+ * Run the setup interview for an empty/new repo.
+ *
+ * - Loads or creates the persisted record.
+ * - Asks only unanswered questions (resume-safe).
+ * - Saves after every answer.
+ * - In non-interactive mode without stored answers, throws a clear error.
+ *
+ * Returns the final record (all questions answered) or throws.
+ */
+async function runInterview(repoRoot, opts = {}) {
+    const now = opts.now ?? new Date();
+    let record = (0, store_js_1.loadOrCreate)(repoRoot, now);
+    // Check whether the interview is already complete.
+    if ((0, store_js_1.nextUnansweredQuestion)(record) === null) {
+        return record;
+    }
+    // Non-interactive guard: if stdin is not a TTY and no readline override, refuse.
+    if (opts.nonInteractive || (!opts.rl && !process.stdin.isTTY)) {
+        throw new Error("polaris init: interview requires an interactive terminal.\n" +
+            "Provide answers via --resume with a stored interview file, or run interactively.");
+    }
+    const rl = opts.rl ??
+        (() => {
+            const iface = (0, promises_1.createInterface)({ input: process.stdin, output: process.stdout });
+            return {
+                question: (prompt) => iface.question(prompt),
+                close: () => iface.close(),
+            };
+        })();
+    try {
+        for (const q of QUESTION_BANK) {
+            if (record.answers[q.key] !== undefined) {
+                // Already answered — skip (resume path).
+                continue;
+            }
+            const raw = await rl.question(`\n${q.prompt}\n> `);
+            // Parse and apply — save immediately so a crash loses at most one answer.
+            const parsed = q.parse(raw);
+            record = {
+                ...record,
+                answers: { ...record.answers, [q.key]: parsed },
+                status: "answered",
+            };
+            (0, store_js_1.saveInterview)(repoRoot, record);
+        }
+    }
+    finally {
+        rl.close();
+    }
+    return record;
+}

package/dist/cli/setup-interview/schema.js

@@ -0,0 +1,16 @@
+"use strict";
+/** Typed schema for .polaris/setup/interview.json */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInterviewRecord = createInterviewRecord;
+/** Create a fresh interview record (status: in-progress). */
+function createInterviewRecord(now = new Date()) {
+    return {
+        schema_version: "1.0",
+        mode: "init",
+        status: "in-progress",
+        started_at: now.toISOString(),
+        answers: {},
+        generation_plan: null,
+        approved_at: null,
+    };
+}

package/dist/cli/setup-interview/store.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInterview = loadInterview;
+exports.saveInterview = saveInterview;
+exports.loadOrCreate = loadOrCreate;
+exports.applyAnswers = applyAnswers;
+exports.markApproved = markApproved;
+exports.nextUnansweredQuestion = nextUnansweredQuestion;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const schema_js_1 = require("./schema.js");
+function interviewPath(repoRoot) {
+    return (0, node_path_1.join)(repoRoot, ".polaris", "setup", "interview.json");
+}
+/**
+ * Load an existing interview record from disk.
+ * Returns null if the file does not exist or cannot be parsed.
+ */
+function loadInterview(repoRoot) {
+    const path = interviewPath(repoRoot);
+    if (!(0, node_fs_1.existsSync)(path))
+        return null;
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Persist an interview record to .polaris/setup/interview.json. */
+function saveInterview(repoRoot, record) {
+    const path = interviewPath(repoRoot);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+}
+/**
+ * Load an existing record or create a fresh one.
+ * Supports --resume: caller passes the return value to continueInterview.
+ */
+function loadOrCreate(repoRoot, now = new Date()) {
+    return loadInterview(repoRoot) ?? (0, schema_js_1.createInterviewRecord)(now);
+}
+/** Merge new answers into the record and transition status to "answered" if appropriate. */
+function applyAnswers(record, answers) {
+    return {
+        ...record,
+        answers: { ...record.answers, ...answers },
+        status: record.status === "approved" ? "approved" : "answered",
+    };
+}
+/** Transition record to "approved" status, recording the approval timestamp. */
+function markApproved(record, now = new Date()) {
+    return {
+        ...record,
+        status: "approved",
+        approved_at: now.toISOString(),
+    };
+}
+/**
+ * Return the next unanswered required question key, or null if all are answered.
+ * Used to resume at the right question after a partial run.
+ */
+function nextUnansweredQuestion(record) {
+    const required = [
+        "project_purpose",
+        "source_roots",
+        "languages",
+        "canonical_doc_folders",
+        "never_touch",
+        "providers_by_role",
+    ];
+    return required.find((key) => record.answers[key] === undefined) ?? null;
+}

package/dist/finalize/index.js

@@ -42,7 +42,7 @@ function getBranch(repoRoot) {
     }
 }
 function normalizeBranchName(branch) {
-    return branch.toLowerCase().replace(/_/g, "-");
+    return branch.toLowerCase().replace(/[_/]/g, "-");
 }
 function extractClusterSlug(clusterId) {
     const match = clusterId.match(/([A-Z]+-\d+)/);
@@ -161,13 +161,14 @@ function checkLibrarianGate(repoRoot, clusterId) {
     const filesCommitted = result.files_committed ?? [];
     for (const file of filesCommitted) {
         const absFile = (0, node_path_1.resolve)(repoRoot, file);
+        // Allowed takes precedence over prohibited — a specific allowed path wins over a broad prohibition.
+        const allowedMatch = allowedWritePaths.find((pattern) => (0, git_custody_js_1.patternMatchesPath)(pattern, absFile));
+        if (allowedMatch)
+            continue;
         const prohibitedMatch = prohibitedWritePaths.find((pattern) => (0, git_custody_js_1.patternMatchesPath)(pattern, absFile));
         if (prohibitedMatch) {
             return `Librarian wrote to prohibited path: ${file} (matched pattern: ${prohibitedMatch})`;
         }
-        const allowedMatch = allowedWritePaths.find((pattern) => (0, git_custody_js_1.patternMatchesPath)(pattern, absFile));
-        if (allowedMatch)
-            continue; // explicitly allowed
         return `Librarian wrote to out-of-scope path: ${file} (not in allowed_write_paths)`;
     }
     try {

package/dist/loop/adapters/foreman-dispatch.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Foreman dispatch — launches the assigned Foreman with a setup-bootstrap
+ * packet through the configured execution adapter.
+ *
+ * Provider selection comes from config (`execution.providerPolicy.foreman`);
+ * no provider-specific logic lives here — the adapter handles that.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchForeman = dispatchForeman;
+const terminal_cli_js_1 = require("./terminal-cli.js");
+/**
+ * Validate that the setup-bootstrap packet has checkpoint gate enforcement.
+ *
+ * This is the "by construction" guard: a packet without a valid checkpoint_gate
+ * (or with self_approval_prohibited !== true) cannot be dispatched. Because
+ * `generateSetupBootstrapPacket` always sets self_approval_prohibited to true,
+ * any packet that fails this check was manually constructed — and is rejected.
+ *
+ * @throws {Error} if checkpoint_gate is absent or self_approval_prohibited is not true.
+ */
+function assertCheckpointGateEnforced(packet) {
+    if (!packet.checkpoint_gate || packet.checkpoint_gate.self_approval_prohibited !== true) {
+        throw new Error(`Cannot dispatch setup-bootstrap packet "${packet.packet_id}": ` +
+            `checkpoint_gate.self_approval_prohibited must be true. ` +
+            `Use generateSetupBootstrapPacket() to produce a valid packet.`);
+    }
+}
+/**
+ * Wraps a SetupBootstrapPacket into a BootstrapPacket-compatible shape
+ * that existing adapters can dispatch. The setup-bootstrap fields are
+ * carried as context so the foreman receives the full packet.
+ */
+function toBootstrapPacket(packet) {
+    return {
+        schema_version: "1.0",
+        run_id: `setup-${packet.mode}-${packet.packet_id}`,
+        cluster_id: `setup-${packet.mode}`,
+        active_child: "",
+        state_file: "",
+        telemetry_file: "",
+        context: {
+            setup_bootstrap: packet,
+        },
+    };
+}
+/**
+ * Dispatch the Foreman with the setup-bootstrap packet.
+ *
+ * Enforces checkpoint gate presence before dispatch — a packet without
+ * self_approval_prohibited: true is rejected, making self-approval
+ * impossible by construction.
+ *
+ * Uses the existing TerminalCliAdapter so provider-specific logic stays
+ * in provider configs — this function is provider-neutral.
+ */
+async function dispatchForeman(input) {
+    assertCheckpointGateEnforced(input.packet);
+    const adapter = new terminal_cli_js_1.TerminalCliAdapter(input.executionConfig);
+    const bootstrapPacket = toBootstrapPacket(input.packet);
+    return adapter.dispatch(bootstrapPacket, {
+        provider: input.provider,
+        dryRun: input.dryRun,
+    });
+}

package/dist/loop/adapters/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAdapter = exports.AgentSubtaskAdapter = exports.TerminalCliAdapter = void 0;
+exports.dispatchForeman = exports.createAdapter = exports.AgentSubtaskAdapter = exports.TerminalCliAdapter = void 0;
 var terminal_cli_js_1 = require("./terminal-cli.js");
 Object.defineProperty(exports, "TerminalCliAdapter", { enumerable: true, get: function () { return terminal_cli_js_1.TerminalCliAdapter; } });
 var agent_subtask_js_1 = require("./agent-subtask.js");
 Object.defineProperty(exports, "AgentSubtaskAdapter", { enumerable: true, get: function () { return agent_subtask_js_1.AgentSubtaskAdapter; } });
 var registry_js_1 = require("./registry.js");
 Object.defineProperty(exports, "createAdapter", { enumerable: true, get: function () { return registry_js_1.createAdapter; } });
+var foreman_dispatch_js_1 = require("./foreman-dispatch.js");
+Object.defineProperty(exports, "dispatchForeman", { enumerable: true, get: function () { return foreman_dispatch_js_1.dispatchForeman; } });

package/dist/loop/dispatch.js

@@ -15,6 +15,11 @@ const body_parser_js_1 = require("./body-parser.js");
 const loader_js_1 = require("../config/loader.js");
 const store_js_1 = require("../cluster-state/store.js");
 const worker_prompt_js_1 = require("./worker-prompt.js");
+function resolveSimplicityMode(state, config) {
+    if (state.simplicity_bypass)
+        return "off";
+    return config?.simplicity?.mode ?? "full";
+}
 const dispatch_boundary_js_1 = require("./dispatch-boundary.js");
 const run_bootstrap_js_1 = require("./run-bootstrap.js");
 const ledger_js_1 = require("./ledger.js");
@@ -659,7 +664,7 @@ function selectChild(state, requestedChild) {
  * @param resultFile - Optional path for the expected result file; non-absolute paths are resolved against `repoRoot`
  * @returns The constructed WorkerPacket ready for dispatch
  */
-function buildPacket(state, childId, stateFile, telemetryFile, repoRoot, resultFile) {
+function buildPacket(state, childId, stateFile, telemetryFile, repoRoot, resultFile, config) {
     const childMeta = state.open_children_meta?.[childId];
     // Hydrate body from cluster snapshot when runtime state lacks it.
     const cachedBody = childMeta?.body;
@@ -694,6 +699,7 @@ function buildPacket(state, childId, stateFile, telemetryFile, repoRoot, resultF
         allowedScope: resolvedScope.length > 0 ? resolvedScope : undefined,
         maxConcurrentWorkers: 1,
         promptMode: (0, worker_prompt_js_1.selectPromptMode)(childId, state),
+        simplicityMode: resolveSimplicityMode(state, config),
         resultFile: canonicalPath(absoluteResultFile(repoRoot, resultFile)),
     });
 }
@@ -912,7 +918,7 @@ function runLoopDispatch(options) {
         step_cursor: "dispatch",
         dispatch_boundary: (0, dispatch_boundary_js_1.advanceDispatchEpoch)(state.dispatch_boundary, childId),
     };
-    const packet = buildPacket(preliminaryState, childId, options.stateFile, telemetryFile, options.repoRoot, canonicalResultFile);
+    const packet = buildPacket(preliminaryState, childId, options.stateFile, telemetryFile, options.repoRoot, canonicalResultFile, loadedConfig);
     const packetFailure = detectPacketGenerationFailure(packet);
     if (packetFailure) {
         appendTelemetry(telemetryFile, {

package/dist/loop/simplicity.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSimplicityCommand = runSimplicityCommand;
+const checkpoint_js_1 = require("./checkpoint.js");
+/**
+ * Handles `polaris simplicity [--bypass | --restore]`.
+ *
+ * --bypass: sets simplicity_bypass: true for the active run (omits discipline ladder from worker prompts).
+ * --restore: clears simplicity_bypass (re-enables the ladder).
+ * bare: prints current bypass status without mutating state.
+ */
+function runSimplicityCommand(opts) {
+    if (!opts.bypass && !opts.restore) {
+        const state = (0, checkpoint_js_1.readState)(opts.stateFile);
+        if (state.simplicity_bypass) {
+            console.log("Simplicity bypass: on — discipline ladder omitted for this run.");
+        }
+        else {
+            console.log("Simplicity bypass: off — discipline mode comes from project config/default.");
+        }
+        return;
+    }
+    const state = (0, checkpoint_js_1.readState)(opts.stateFile);
+    if (opts.bypass) {
+        state.simplicity_bypass = true;
+        (0, checkpoint_js_1.writeStateAtomic)(opts.stateFile, state);
+        console.log("Simplicity bypass enabled — discipline ladder will be omitted from worker prompts for this run.");
+        return;
+    }
+    // restore
+    state.simplicity_bypass = false;
+    (0, checkpoint_js_1.writeStateAtomic)(opts.stateFile, state);
+    console.log("Simplicity bypass cleared — discipline ladder will be injected into worker prompts.");
+}

package/dist/loop/worker-packet.js

@@ -250,7 +250,7 @@ function compileImplPacket(input) {
         `Create exactly ONE git commit: [${input.childId}] ${childTitle}.`,
         `Do NOT modify open_children or completed_children in ${input.stateFile}. The parent runtime (loop continue) owns that state transition.`,
         `Append a telemetry event to ${input.telemetryFile}.`,
-        `Write compact return JSON to stdout (fields: ${exports.IMPL_RETURN_CONTRACT.join(', ')}).`,
+        `Write compact return JSON to stdout (fields: ${exports.IMPL_RETURN_CONTRACT.join(', ')}). next_recommended_action MUST be exactly "continue" on success, "stop" on unresolvable blocker, or "investigate" if manual review is needed.`,
         `TERMINATE SESSION IMMEDIATELY. Do not select or execute the next child.`,
     ];
     // Build compact or full prompt; primary_goal uses the structured template.
@@ -265,6 +265,7 @@ function compileImplPacket(input) {
         allowedScope: resolvedScope,
         validationCommands: resolvedValidation,
         mode: promptMode,
+        simplicityMode: input.simplicityMode,
     });
     return {
         schema_version: '2.1',

package/dist/loop/worker-prompt.js

@@ -57,6 +57,29 @@ function selectPromptMode(childId, state, override) {
         return override;
     return isNarrowChild(childId, state) ? 'compact' : 'full';
 }
+// ── Discipline section ────────────────────────────────────────────────────────
+function buildDisciplineSection(mode) {
+    if (mode === "off")
+        return [];
+    const lines = [
+        "## Implementation Discipline",
+        "Before writing code, stop at the first rung that holds:",
+        "",
+        "1. Does this need to exist?   → no: skip it (YAGNI)",
+        "2. Stdlib does it?            → use it",
+        "3. Native platform feature?   → use it",
+        "4. Installed dependency?      → use it",
+        "5. One line?                  → one line",
+        "6. Only then: the minimum that works",
+        "",
+        "Lazy, not negligent: validation, error handling, security, and accessibility are never on the chopping block.",
+    ];
+    if (mode === "full") {
+        lines.push("", "When you defer a simplification for later, mark it inline:", "  // ponytail: <what you deferred and why>");
+    }
+    lines.push("");
+    return lines;
+}
 // ── Builder ───────────────────────────────────────────────────────────────────
 /**
  * Build a compact or full worker dispatch prompt.
@@ -80,6 +103,10 @@ function buildWorkerPrompt(input) {
     lines.push('## Goal');
     lines.push(input.goal.trim());
     lines.push('');
+    // ── Implementation Discipline ─────────────────────────────────────────────
+    for (const line of buildDisciplineSection(input.simplicityMode ?? 'full')) {
+        lines.push(line);
+    }
     // ── Scope ─────────────────────────────────────────────────────────────────
     lines.push('## Scope');
     if (input.scopeTouch.length > 0) {
@@ -256,5 +283,6 @@ function buildPromptFromPacketInput(input) {
         telemetryFile: input.telemetryFile,
         issueContext: input.issueContext,
         mode: input.mode,
+        simplicityMode: input.simplicityMode,
     });
 }

package/dist/skill-packet/generator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUPPORTED_SKILLS = exports.SKILL_ROLE_MAP = void 0;
+exports.generateSetupBootstrapPacket = generateSetupBootstrapPacket;
 exports.generateSkillPacket = generateSkillPacket;
 const node_crypto_1 = require("node:crypto");
 exports.SKILL_ROLE_MAP = {
@@ -10,6 +11,8 @@ exports.SKILL_ROLE_MAP = {
     promote: "Librarian",
     triage: "Librarian",
     review: "Librarian",
+    catalog: "Librarian",
+    reconcile: "Librarian",
 };
 const ROLE_SUMMARIES = {
     Analyst: "The Analyst gathers evidence, assesses feasibility, and produces implementation-ready plans. The Analyst shapes work but never executes it.",
@@ -258,6 +261,136 @@ function buildReviewPacket() {
         ],
     };
 }
+const SETUP_BOOTSTRAP_CHECKPOINTS = [
+    "canon",
+    "doc-movement",
+    "instruction-files",
+    "graph-root",
+    "route-scaffold",
+    "source-mutation",
+];
+/**
+ * Builds the checkpoint gate that is embedded in every setup-bootstrap packet.
+ *
+ * Each checkpoint gate entry is a halt instruction — the Foreman MUST stop
+ * and surface the gate to the operator before proceeding. Self-approval is
+ * structurally impossible: `self_approval_prohibited` is typed as `true` and
+ * this function never sets it to anything else.
+ */
+function buildCheckpointGate() {
+    const gateInstruction = (name) => `HALT at checkpoint "${name}": stop, surface this gate to the operator, and wait for explicit approval before proceeding. You may not self-approve.`;
+    return {
+        gates: {
+            canon: gateInstruction("canon"),
+            "doc-movement": gateInstruction("doc-movement"),
+            "instruction-files": gateInstruction("instruction-files"),
+            "graph-root": gateInstruction("graph-root"),
+            "route-scaffold": gateInstruction("route-scaffold"),
+            "source-mutation": gateInstruction("source-mutation"),
+        },
+        self_approval_prohibited: true,
+        enforcement_note: "Checkpoint gates are non-optional. The Foreman must halt and surface each gate to the operator. " +
+            "Proceeding without explicit operator approval is a protocol violation.",
+    };
+}
+function generateSetupBootstrapPacket(mode) {
+    return {
+        packet_id: (0, node_crypto_1.randomUUID)(),
+        packet_kind: "setup-bootstrap",
+        active_role: "Foreman",
+        role_file: ".polaris/skills/polaris-run/SKILL.md",
+        mode,
+        authority_boundaries: [
+            "Read repository structure and existing configuration files",
+            "Create or update Polaris configuration and scaffold files",
+            "Dispatch Workers for bounded setup sub-tasks",
+            "Coordinate approval checkpoints before advancing to the next setup phase",
+            "Write to .polaris/ directories as part of init or adopt setup",
+            "Update POLARIS.md and SUMMARY.md within the project root",
+        ],
+        prohibited_actions: [
+            "Mutate source files without an approved checkpoint (unapproved mutation is forbidden)",
+            "Implement features directly — all implementation must be delegated to a Worker",
+            "Advance past an approval checkpoint without explicit user confirmation",
+            "Self-approve any checkpoint — operator approval is mandatory and cannot be delegated to the Foreman",
+            "Modify tracker state or issue descriptions during setup",
+        ],
+        approval_checkpoints: SETUP_BOOTSTRAP_CHECKPOINTS,
+        checkpoint_gate: buildCheckpointGate(),
+        stop_conditions: [
+            "All setup phases complete and scaffold is valid",
+            "An approval checkpoint is reached — pause and await user confirmation",
+            "A required configuration value is missing and cannot be inferred",
+            "A Worker returns a failure result during setup",
+        ],
+        generated_at: new Date().toISOString(),
+    };
+}
+function buildCatalogPacket() {
+    return {
+        authority_boundaries: [
+            "Read packet-scoped POLARIS.md and SUMMARY.md files",
+            "Update cognition files only within packet-allowed write paths",
+            "Read smartdocs/raw/ and classify documents through supported Polaris CLI commands",
+            "Auto-place only high-confidence documents",
+            "Leave low-confidence documents in raw when unattended or request operator direction",
+        ],
+        prohibited_actions: [
+            "Modify implementation source code, tests, or configuration",
+            "Write outside packet-allowed paths",
+            "Auto-place low-confidence documents",
+            "Move or copy SmartDocs directly instead of using supported CLI commands",
+            "Call polaris loop continue or polaris finalize",
+            "Git push or create a pull request",
+        ],
+        allowed_outputs: [
+            "Updated POLARIS.md and SUMMARY.md files in packet-allowed paths",
+            "Classified documents placed through supported Polaris CLI commands",
+            "A sealed local cognition and document commit",
+            "A report of deferred low-confidence documents",
+        ],
+        deliverables: [
+            "Packet-scoped cognition reconciled",
+            "Raw documents classified or explicitly deferred",
+            "All changes recorded in one sealed local commit",
+        ],
+        stop_conditions: [
+            "All packet-scoped cognition and raw documents processed",
+            "A required command is unsupported by the installed CLI",
+            "A requested write falls outside packet-allowed paths",
+            "An unresolved conflict requires operator direction",
+        ],
+    };
+}
+function buildReconcilePacket() {
+    return {
+        authority_boundaries: [
+            "Read packet-scoped folders and their POLARIS.md and SUMMARY.md files",
+            "Update cognition files only within packet-allowed write paths",
+            "Create one sealed local cognition commit",
+        ],
+        prohibited_actions: [
+            "Modify implementation source code, tests, or configuration",
+            "Move, ingest, classify, or promote documents",
+            "Write outside packet-allowed paths",
+            "Call polaris loop continue or polaris finalize",
+            "Git push or create a pull request",
+        ],
+        allowed_outputs: [
+            "Updated POLARIS.md and SUMMARY.md files in packet-allowed paths",
+            "A sealed local cognition commit",
+        ],
+        deliverables: [
+            "Packet-scoped cognition reconciled with completed work",
+            "All cognition changes recorded in one sealed local commit",
+        ],
+        stop_conditions: [
+            "All packet-scoped cognition reconciled",
+            "A requested write falls outside packet-allowed paths",
+            "Work evidence is missing or contradictory",
+        ],
+    };
+}
 function generateSkillPacket(skillName, config) {
     const active_role = exports.SKILL_ROLE_MAP[skillName];
     const role_summary = ROLE_SUMMARIES[active_role];
@@ -288,6 +421,12 @@ function generateSkillPacket(skillName, config) {
         case "review":
             body = buildReviewPacket();
             break;
+        case "catalog":
+            body = buildCatalogPacket();
+            break;
+        case "reconcile":
+            body = buildReconcilePacket();
+            break;
     }
     return {
         packet_id,
@@ -299,4 +438,13 @@ function generateSkillPacket(skillName, config) {
         generated_at,
     };
 }
-exports.SUPPORTED_SKILLS = ["analyze", "run", "ingest", "promote", "triage", "review"];
+exports.SUPPORTED_SKILLS = [
+    "analyze",
+    "run",
+    "ingest",
+    "promote",
+    "triage",
+    "review",
+    "catalog",
+    "reconcile",
+];