smol-symphony 0.2.0 → 0.3.1

package/dist/core/actions/predicates.js

@@ -0,0 +1,111 @@
+// FCIS rewrite — pure `if:` predicate evaluation (ported from
+// src/actions/predicates.ts + predicate-env.ts of the reference orchestrator).
+//
+// The reference `evaluatePredicate` was async because the branch_exists /
+// file_present shapes reached IO through an injected `PredicateEnv`
+// (git rev-parse / fs.stat). In the functional core that IO is FORBIDDEN, so
+// this module is split into two pure, synchronous halves:
+//
+//   1. `evaluatePredicate(predicate, ctx, workspacePath)` decides AS DATA. It
+//      either RESOLVES immediately (null/undefined → true; string-truthy;
+//      empty-after-render → false) or EMITS a probe Effect the shell answers:
+//        - { branch_exists } → a `git.branch_exists` Effect, and
+//        - { file_present }  → an `fs.path_exists` Effect.
+//      Unknown `$var` references surface as an ERROR decision (the reference
+//      threw a TemplateError; silent "" expansion masked operator typos).
+//
+//   2. `foldPredicateProbe(result)` folds the shell's EffectResult boolean back
+//      into the final predicate value once the probe has run.
+//
+// 100% SYNCHRONOUS. No async / await / Promise. No IO, no node: imports, no
+// clock or randomness. Imports ONLY from src/types (and the sibling core
+// templating module). (NodeNext ESM → .js extensions on relative imports.)
+import { renderField } from './template.js';
+import { joinPosix } from '../path.js';
+// ─── template substitution ────────────────────────────────────────────────────
+// Shared with the core planner via `renderField` (same $-grammar, same
+// unknown-var error). `renderField` labels the error with the action-field name;
+// here the relevant label IS the offending variable, which the reference's
+// PredicateEnv surfaced. We re-label the returned TemplateError with the bad
+// variable (parsed out of the message renderField already embeds) so callers see
+// `field: "<varname>"`, matching the reference predicate-env behavior.
+const BAD_VAR_RE = /unknown template variable "\$([A-Za-z_][A-Za-z0-9_]*)"/;
+function render(template, ctx) {
+    const r = renderField('<predicate>', template, ctx);
+    if (r.ok)
+        return { ok: true, text: r.value };
+    const field = BAD_VAR_RE.exec(r.error.message)?.[1] ?? r.error.field;
+    return { ok: false, error: { field, message: r.error.message } };
+}
+// Path join is the canonical lexical `joinPosix` from core/path.ts (this module
+// was the SUPERSET behaviour that became canonical — empty-base/absolute-rel
+// handling). The reference used node:path, forbidden in the pure core.
+/**
+ * Decide a predicate against the context, AS DATA.
+ *
+ * `null`/`undefined` → resolved true (no `if:` → run unconditionally).
+ *
+ * String form is a truthiness check on the rendered template: `if: $repo`
+ * resolves true iff `$repo` renders to non-empty after trimming. An empty (or
+ * empty-after-render) string is explicitly FALSE — the intent of `if: $repo`
+ * with `$repo` unset is "skip when the var is empty", not "always run".
+ *
+ * `{ branch_exists }` / `{ file_present }` render their argument, short-circuit
+ * to resolved-false on an empty ref/path, otherwise EMIT a probe Effect the
+ * shell runs; the boolean is folded back via `foldPredicateProbe`.
+ *
+ * An unknown `$var` anywhere returns a `{ kind: 'error' }` decision (the
+ * reference threw a TemplateError).
+ */
+export function evaluatePredicate(predicate, ctx, workspacePath) {
+    if (predicate === null || predicate === undefined) {
+        return { kind: 'resolved', value: true };
+    }
+    if (typeof predicate === 'string') {
+        const r = render(predicate, ctx);
+        if (!r.ok)
+            return { kind: 'error', error: r.error };
+        return { kind: 'resolved', value: r.text.trim().length > 0 };
+    }
+    if ('branch_exists' in predicate) {
+        const r = render(predicate.branch_exists, ctx);
+        if (!r.ok)
+            return { kind: 'error', error: r.error };
+        const ref = r.text.trim();
+        if (ref.length === 0)
+            return { kind: 'resolved', value: false };
+        return {
+            kind: 'probe',
+            effect: { family: 'git', kind: 'branch_exists', cwd: workspacePath, ref },
+        };
+    }
+    if ('file_present' in predicate) {
+        const r = render(predicate.file_present, ctx);
+        if (!r.ok)
+            return { kind: 'error', error: r.error };
+        const file = r.text.trim();
+        if (file.length === 0)
+            return { kind: 'resolved', value: false };
+        return {
+            kind: 'probe',
+            effect: { family: 'fs', kind: 'path_exists', path: joinPosix(workspacePath, file) },
+        };
+    }
+    // Unreachable for a well-typed ActionPredicate; mirror the reference's
+    // defensive `return false`.
+    return { kind: 'resolved', value: false };
+}
+/**
+ * Fold the shell's EffectResult for a `{ kind: 'probe' }` decision back into the
+ * final predicate boolean. Accepts the two probe result shapes this module can
+ * emit (`branch_exists` / `path_exists`); any other / failed result folds to
+ * `false` (a probe that could not run means "predicate not satisfied", matching
+ * the reference's missing-ref / fs-error → false behavior).
+ */
+export function foldPredicateProbe(result) {
+    if ('kind' in result && (result.kind === 'branch_exists' || result.kind === 'path_exists')) {
+        return result.exists;
+    }
+    return false;
+}
+//# sourceMappingURL=predicates.js.map

package/dist/core/actions/predicates.js.map

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

package/dist/core/actions/run-fold.js

@@ -0,0 +1,248 @@
+// FCIS rewrite — pure executor state machine for the typed-action DAG.
+//
+// Ported faithfully from the reference `src/actions/executor.ts`
+// (`runEffects` + `runWithRetry` + `finalizeOutcome`/`finalizeFailure`). The
+// reference was an async driver that AWAITED `applyAction`, slept on
+// `node:timers/promises`, and called `log.warn` directly. In the functional
+// core all of that becomes DATA:
+//
+//   • IO (running the action attempt) happens in the shell. The shell applies
+//     one attempt, then hands the resulting `ActionOutcome` back to this fold.
+//   • The retry backoff `delay()` becomes a returned `timer.sleep` Effect plus a
+//     `retry` decision telling the shell to re-apply the same action.
+//   • The diagnostic `log.warn`/`log.debug` calls become `log.emit` Effects.
+//   • The ledger (bounded `ActionStatus[]`, most-recent-first) is THREADED
+//     through as plain data: each call takes the prior ledger and returns the
+//     next one.
+//
+// The shell drives this as a loop per action:
+//   1. beginAction(...)            → push an in_progress ledger row.
+//   2. apply the action (IO)       → produce an ActionOutcome.
+//   3. foldActionOutcome(...)      → decide retry / route / abort / done,
+//                                     emit Effects, and return the next ledger.
+//   4. on `retry`, the shell sleeps (it already has the timer.sleep Effect),
+//      re-applies, and folds again with an incremented `attempt`.
+//
+// Predicate evaluation, template-render failures, and skip-on-`if=false` are
+// handled by sibling core modules (`predicates.ts`, `template.ts`); the helpers
+// here cover the "an attempt ran and produced an outcome" half of the loop plus
+// the ledger bookkeeping the shell needs around it.
+//
+// 100% SYNCHRONOUS. No async / await / Promise. No IO, no node: imports, no
+// wall clock or randomness (an ISO timestamp is injected as a plain string).
+// Imports ONLY from src/types. (NodeNext ESM → .js extensions on relative
+// imports.)
+/**
+ * Most-recent-first slice length surfaced on the snapshot. The reference keeps
+ * twice this many rows internally (so a burst of in_progress→error→… updates
+ * doesn't evict still-relevant rows before they finalize) and slices to
+ * `MAX_ACTION_HISTORY` only when emitting.
+ */
+export const MAX_ACTION_HISTORY = 16;
+const LEDGER_CAP = MAX_ACTION_HISTORY * 2;
+// ─── ledger bookkeeping (pure; the reference's `push` / `upd` closures) ───────
+/**
+ * Push a fresh in_progress row for an action attempt, most-recent-first, and
+ * cap the ledger at `LEDGER_CAP` rows. Returns the NEXT ledger (does not mutate
+ * the input).
+ *
+ * Mirrors the reference's `push` closure that `unshift`ed an in_progress row in
+ * `runOneEffect` before evaluating the predicate / applying the action.
+ */
+export function beginAction(ledger, input) {
+    const row = {
+        resource: input.resource,
+        action: input.action,
+        state: 'in_progress',
+        started_at: input.nowIso,
+        finished_at: null,
+        error: null,
+    };
+    const next = [row, ...ledger];
+    if (next.length > LEDGER_CAP)
+        next.length = LEDGER_CAP;
+    return next;
+}
+/**
+ * Mark the most-recent in_progress row for `action` with the given patch.
+ * Returns the NEXT ledger. Mirrors the reference's `upd` closure (find the
+ * first in_progress row keyed by action name; spread the patch onto it).
+ *
+ * When no matching in_progress row exists the ledger is returned unchanged
+ * (the reference's `upd` no-ops on a missing index).
+ */
+export function updateAction(ledger, action, patch) {
+    const idx = ledger.findIndex((a) => a.action === action && a.state === 'in_progress');
+    if (idx < 0)
+        return ledger.slice();
+    const next = ledger.slice();
+    next[idx] = { ...next[idx], ...patch };
+    return next;
+}
+// ─── retry / route / abort decision ───────────────────────────────────────────
+/**
+ * Exponential backoff for the `attempt`-th (0-based) failed action attempt:
+ * `backoffMs * 2^attempt`. Mirrors the reference's
+ * `policy.retry.backoff_ms * Math.pow(2, attempt)`.
+ */
+export function actionBackoffMs(policy, attempt) {
+    return policy.backoffMs * Math.pow(2, attempt);
+}
+function warn(message, fields) {
+    return { family: 'log', kind: 'emit', level: 'warn', message, fields };
+}
+/**
+ * Fold one applied-action `ActionOutcome` against its `NormalizedActionPolicy`,
+ * threading the `ActionStatus` ledger and emitting the side effects as data.
+ *
+ * `attempt` is the 0-based number of the attempt that just produced `outcome`
+ * (0 for the first try). The reference's `runWithRetry` loop semantics:
+ *
+ *   • `outcome.ok || outcome.route_to` short-circuits the retry loop. We never
+ *     retry a routed failure — a routed handoff is clean, not a transient error.
+ *   • otherwise, if `attempt < retryCount`, schedule a retry with
+ *     `backoffMs * 2^attempt` backoff.
+ *   • otherwise the retries are exhausted → finalize the failure.
+ *
+ * Finalization (the reference's `finalizeOutcome` / `finalizeFailure`):
+ *   • success → `done`, ledger row finalized.
+ *   • failure → route to `outcome.route_to` ?? (policy.then is an object ?
+ *     policy.then.route_to : null). A non-null route → `route`; null → `abort`.
+ *     Ledger row finalized to `error` with the failure reason either way.
+ */
+export function foldActionOutcome(input) {
+    const { action, outcome, policy, attempt, nowIso } = input;
+    // ── success ────────────────────────────────────────────────────────────
+    if (outcome.ok) {
+        return {
+            decision: { kind: 'done' },
+            ledger: updateAction(input.ledger, action, { state: 'done', finished_at: nowIso }),
+            effects: [],
+        };
+    }
+    const reason = outcome.reason ?? 'unknown';
+    // ── retry (only when NOT routed and retries remain) ──────────────────────
+    // A routed failure is a clean handoff and is never retried — mirrors the
+    // reference's `if (outcome.route_to) return outcome` short-circuit ahead of
+    // the retry-budget check.
+    if (!outcome.route_to && attempt < policy.retryCount) {
+        const backoffMs = actionBackoffMs(policy, attempt);
+        return {
+            decision: { kind: 'retry', attempt: attempt + 1, backoffMs },
+            // Leave the in_progress row in place: the attempt is still "running"
+            // from the dashboard's view until it ultimately succeeds or exhausts.
+            ledger: input.ledger.slice(),
+            effects: [
+                warn('action retrying', {
+                    action,
+                    attempt: attempt + 1,
+                    next_backoff_ms: backoffMs,
+                    error: outcome.reason,
+                }),
+                { family: 'timer', kind: 'sleep', ms: backoffMs },
+            ],
+        };
+    }
+    // ── terminal failure: route or abort ─────────────────────────────────────
+    const route = outcome.route_to ?? (typeof policy.then === 'object' ? policy.then.route_to : null);
+    const ledger = updateAction(input.ledger, action, {
+        state: 'error',
+        finished_at: nowIso,
+        error: reason,
+    });
+    if (route !== null) {
+        return {
+            decision: { kind: 'route', routeTo: route, reason },
+            ledger,
+            effects: [warn('action failed', { action, reason, route_to: route })],
+        };
+    }
+    return {
+        decision: { kind: 'abort', reason },
+        ledger,
+        effects: [warn('action failed', { action, reason, route_to: null })],
+    };
+}
+// ─── render-failure / skip helpers (the non-retry ledger transitions) ─────────
+/**
+ * Finalize the in_progress row for an action whose template render failed (the
+ * reference's `render_failed` Effect branch). Returns the next ledger and an
+ * `abort` decision — a render failure stops the cleanup loop, mirroring the
+ * reference returning `{ aborted: true }`.
+ */
+export function foldRenderFailed(input) {
+    const ledger = updateAction(input.ledger, input.action, {
+        state: 'error',
+        finished_at: input.nowIso,
+        error: input.error,
+    });
+    return {
+        decision: { kind: 'abort', reason: input.error },
+        ledger,
+        effects: [warn('action template render failed', { action: input.action, error: input.error })],
+    };
+}
+/**
+ * Finalize the in_progress row for an action whose `if:` predicate resolved
+ * false (skip). The reference marked the row `done` (skips are not failures) and
+ * continued. Returns the next ledger and a `done` decision.
+ */
+export function foldSkipped(input) {
+    const ledger = updateAction(input.ledger, input.action, {
+        state: 'done',
+        finished_at: input.nowIso,
+    });
+    return {
+        decision: { kind: 'done' },
+        ledger,
+        effects: [
+            { family: 'log', kind: 'emit', level: 'debug', message: 'action skipped', fields: { action: input.action, reason: 'if=false' } },
+        ],
+    };
+}
+/**
+ * Finalize the in_progress row for an action whose `if:` predicate could not be
+ * evaluated (an error decision, e.g. an unknown `$var`). The reference treated
+ * this as an abort (it returned `{ aborted: true, reason }`).
+ */
+export function foldPredicateError(input) {
+    const ledger = updateAction(input.ledger, input.action, {
+        state: 'error',
+        finished_at: input.nowIso,
+        error: input.error,
+    });
+    return { decision: { kind: 'abort', reason: input.error }, ledger, effects: [] };
+}
+// ─── snapshot packing (the reference's `toActionsSnapshot`) ──────────────────
+/**
+ * Aggregate a finished cleanup loop into the runner's result shape (the
+ * reference's `ActionExecResult`). `ok` is true iff the loop did not abort;
+ * `route_to`/`reason` carry the last route/abort decision the loop hit.
+ *
+ * Kept here (not in the snapshot packer) because the runner needs both the
+ * loop's terminal decision AND the bounded ledger.
+ */
+export function summarizeRun(input) {
+    return {
+        ok: input.abortReason === null,
+        reason: input.abortReason,
+        route_to: input.routeTo,
+        actions: input.ledger.slice(0, MAX_ACTION_HISTORY),
+    };
+}
+/**
+ * Pack a finished run into a `Snapshot`-shaped record the orchestrator surfaces
+ * alongside reconciler resources. `ready` mirrors the run's `ok`; `last_error`
+ * is the most-recent errored row's message. Mirrors the reference's
+ * `toActionsSnapshot`.
+ */
+export function toActionsSnapshot(id, result) {
+    const lastErr = result.actions.find((a) => a.state === 'error')?.error ?? null;
+    return {
+        id,
+        ready: result.ok,
+        last_error: lastErr,
+        actions: result.actions.slice(0, MAX_ACTION_HISTORY),
+    };
+}
+//# sourceMappingURL=run-fold.js.map

package/dist/core/actions/run-fold.js.map

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

package/dist/core/actions/template.js

@@ -0,0 +1,118 @@
+// FCIS rewrite — strict template render.
+//
+// FUNCTIONAL CORE. Every function here is SYNCHRONOUS and pure: (data) -> data.
+// No IO, no async, no clock, no randomness, no Effects. Imports ONLY from
+// src/types. Ports the original behavior of src/actions/templating.ts
+// ({renderTemplate, renderTree}) — $-substitution against the fixed
+// ActionContext namespace, unknown-var = error.
+//
+// The behavioral change from the original, forced by the FCIS layout:
+// TemplateError is DATA ({ field, message }, per src/types/actions.ts), not a
+// thrown class. renderField returns a discriminated result; the caller (a future
+// core planner) folds the error into an ActionOutcome instead of try/catch. The
+// legacy "throw" shape is preserved only as the strict `renderOrThrow` helper for
+// call-sites that still want it.
+// ─── Template rendering ──────────────────────────────────────────────────────
+// `$name` / `\$name` (escape). Matches the original VAR_RE exactly:
+//   group 1 = optional leading backslash (the escape)
+//   group 2 = the identifier
+const VAR_RE = /(\\?)\$([A-Za-z_][A-Za-z0-9_]*)/g;
+/**
+ * Substitute `$name` references in `template` against the fixed ActionContext
+ * namespace. Faithful to src/actions/templating.ts:
+ *   • `$name`            → the named ActionContext field (null/undefined → "").
+ *   • `\$name`           → literal `$name` (escape).
+ *   • `$` + non-word     → left alone (regex only matches `$` + identifier).
+ *   • unknown `$name`    → ERROR (the original threw; silent "" expansion masks
+ *                          operator typos — the `$SYMPHONY_PR_TITTLE` bug).
+ *
+ * `field` is the action-field label (e.g. "title_from") carried into the
+ * TemplateError so a failure points at the offending field, matching the new
+ * TemplateError data shape in src/types/actions.ts.
+ */
+export function renderField(field, template, ctx) {
+    // Non-string passthrough is handled by renderTree; renderField is the
+    // string-typed leaf. A non-string here is a programming error, but we mirror
+    // the original's defensive passthrough rather than crash.
+    if (typeof template !== 'string') {
+        return { ok: true, value: template };
+    }
+    // `name in ctx` membership, typed without `any` (ActionContext is a plain
+    // object literal, so own + inherited enumerable keys coincide).
+    const vars = ctx;
+    let firstError = null;
+    const out = template.replace(VAR_RE, (_full, escape, name) => {
+        if (escape === '\\')
+            return `$${name}`;
+        if (!(name in vars)) {
+            firstError ??= {
+                field,
+                message: `unknown template variable "$${name}" (available: ${Object.keys(vars).join(', ')})`,
+            };
+            return ''; // value discarded; firstError short-circuits the return below.
+        }
+        const v = vars[name];
+        return v === null || v === undefined ? '' : String(v);
+    });
+    if (firstError !== null)
+        return { ok: false, error: firstError };
+    return { ok: true, value: out };
+}
+/**
+ * Strict variant matching the ORIGINAL throwing contract for the rare call-site
+ * that wants it. Prefer renderField (error-as-data) in core; this exists so the
+ * shell can keep a one-liner where a throw is the natural control flow.
+ *
+ * NOTE: throwing is acceptable here only because the thrown value carries the
+ * same TemplateError DATA — callers should catch and fold, not let it escape an
+ * effect boundary.
+ */
+export function renderOrThrow(template, ctx) {
+    const r = renderField('<template>', template, ctx);
+    if (!r.ok) {
+        const e = new Error(r.error.message);
+        e.name = 'TemplateError';
+        e.templateError = r.error;
+        throw e;
+    }
+    return r.value;
+}
+/**
+ * Render every string leaf of a value against the ActionContext, recursing into
+ * arrays and plain objects. Numbers / booleans / null pass through unchanged.
+ * Faithful to src/actions/templating.ts:renderTree, but returns the first
+ * TemplateError as data instead of throwing.
+ *
+ * `path` seeds the `field` label on errors (e.g. `cmd[1]`, `env.FOO`) so a
+ * failure deep in an action record still points at the offending leaf.
+ */
+export function renderTree(value, ctx, path = '') {
+    if (typeof value === 'string') {
+        const r = renderField(path || '<root>', value, ctx);
+        if (!r.ok)
+            return r;
+        return { ok: true, value: r.value };
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        for (let i = 0; i < value.length; i++) {
+            const r = renderTree(value[i], ctx, `${path}[${i}]`);
+            if (!r.ok)
+                return r;
+            out.push(r.value);
+        }
+        return { ok: true, value: out };
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const r = renderTree(v, ctx, path ? `${path}.${k}` : k);
+            if (!r.ok)
+                return r;
+            out[k] = r.value;
+        }
+        return { ok: true, value: out };
+    }
+    return { ok: true, value };
+}
+//# sourceMappingURL=template.js.map

package/dist/core/actions/template.js.map

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

package/dist/core/cli/args.js

@@ -0,0 +1,116 @@
+// FCIS rewrite — pure CLI argument parsing for the `symphony` binary.
+//
+// Functional core: every export here is a pure, synchronous (data) -> data
+// function. No IO, no clock, no randomness, no node: imports, no process.
+// Imports ONLY from src/types.
+//
+// Ported from src/bin/cli-args.ts:parseCli. The original performed three side
+// effects inline that violate the core contract and are RETURNED here instead:
+//   1. `process.exit(2)` on a bad/unexpected arg → a returned `{ kind: 'error' }`
+//      directive carrying the message + exit code; the shell raises it.
+//   2. `-h/--help` prints usage then `process.exit(0)` → a returned
+//      `{ kind: 'help' }` directive carrying the usage text + exit code 0.
+//   3. `path.resolve(process.cwd(), 'WORKFLOW.yaml')` for the default workflow path
+//      → the CWD is INJECTED as a parameter and the join is a pure string op.
+//
+// The shell (composition root) calls `parseCli(argv, cwd)`, and on a
+// non-`ok` result writes the directive's message to the matching stream and
+// exits with the directive's code.
+/** Default workflow filename used when no path argument is supplied. */
+export const DEFAULT_WORKFLOW_FILENAME = 'WORKFLOW.yaml';
+/** Usage text (ported verbatim from the original `-h/--help` branch). */
+export const USAGE = `symphony [path-to-WORKFLOW.yaml] [--port PORT] [--verbose]\n` +
+    `symphony doctor [path-to-WORKFLOW.yaml] [--port PORT]\n` +
+    `symphony reconcile [path-to-WORKFLOW.yaml] [--force] [--port PORT]\n\n` +
+    `If path is omitted, ./WORKFLOW.yaml is used.\n` +
+    `\`doctor\` runs every adoption-prerequisite probe non-fatally, prints a\n` +
+    `PASS/FAIL line per check plus a one-line fix for each FAIL, and exits 0\n` +
+    `iff every check passes.\n` +
+    `\`reconcile --force\` requests an immediate reconcile pass (VM / workspace /\n` +
+    `PR janitors) at startup.\n` +
+    `\`--verbose\` (alias \`--foreground\`, \`-v\`) mirrors structured logs to the\n` +
+    `console; by default they go to the log file only so the console stays clean.\n`;
+/** Pure path join: trailing-slash-tolerant `${cwd}/${name}`, no node:path. */
+function joinDefaultWorkflow(cwd, name) {
+    const base = cwd.replace(/\/+$/, '');
+    // An empty/`/` cwd collapses to an absolute path at root; otherwise join.
+    return base === '' ? `/${name}` : `${base}/${name}`;
+}
+/** The `--port` invalid-value message, shared by both `--port V` and `--port=V`. */
+const invalidPort = (raw) => ({ kind: 'error', message: `error: invalid --port value: ${raw}\n`, exitCode: 2 });
+/**
+ * Parse `argv` (already sliced past `node script`) into a {@link CliResult}.
+ *
+ * `cwd` is injected (the original read `process.cwd()`); it is only used to
+ * resolve the default WORKFLOW.yaml path when no positional path is supplied.
+ *
+ * Faithful port of src/bin/cli-args.ts:parseCli — same subcommand detection,
+ * same flag handling, same precedence — but every `process.exit`/stream write
+ * is returned as a {@link CliHelp}/{@link CliError} directive for the shell.
+ */
+export function parseCli(argv, cwd) {
+    // Detect subcommands. `reconcile`/`doctor` share the parsed-args skeleton with
+    // the default `serve` mode; the subcommand is preserved verbatim (collapsing
+    // `reconcile`→`serve` would let the missing-workflow scaffold prompt fire on a
+    // `reconcile` invocation that has nothing to scaffold against).
+    let subcommand = 'serve';
+    let rest = argv;
+    if (argv[0] === 'reconcile') {
+        subcommand = 'reconcile';
+        rest = argv.slice(1);
+    }
+    else if (argv[0] === 'doctor') {
+        subcommand = 'doctor';
+        rest = argv.slice(1);
+    }
+    let workflow = null;
+    let port = null;
+    let reconcileForce = false;
+    let verbose = false;
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a === '--port' || a === '-p') {
+            const v = rest[++i];
+            if (v === undefined) {
+                return { kind: 'error', message: `error: --port requires a value\n`, exitCode: 2 };
+            }
+            const n = parseInt(v, 10);
+            if (!Number.isFinite(n) || n < 0)
+                return invalidPort(v);
+            port = n;
+        }
+        else if (a.startsWith('--port=')) {
+            const n = parseInt(a.slice('--port='.length), 10);
+            // The original interpolated the WHOLE arg (`--port=foo`) into the message.
+            if (!Number.isFinite(n) || n < 0)
+                return invalidPort(a);
+            port = n;
+        }
+        else if (subcommand === 'reconcile' && a === '--force') {
+            reconcileForce = true;
+        }
+        else if (a === '--verbose' || a === '-v' || a === '--foreground') {
+            verbose = true;
+        }
+        else if (a === '-h' || a === '--help') {
+            return { kind: 'help', message: USAGE, exitCode: 0 };
+        }
+        else if (workflow === null) {
+            workflow = a;
+        }
+        else {
+            return { kind: 'error', message: `error: unexpected argument: ${a}\n`, exitCode: 2 };
+        }
+    }
+    return {
+        kind: 'ok',
+        cli: {
+            subcommand,
+            workflow: workflow ?? joinDefaultWorkflow(cwd, DEFAULT_WORKFLOW_FILENAME),
+            port,
+            reconcileForce,
+            verbose,
+        },
+    };
+}
+//# sourceMappingURL=args.js.map

package/dist/core/cli/args.js.map

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