@open-agent-toolkit/cli 0.3.21 → 0.3.23

package/dist/commands/project/dispatch/record.js

@@ -2,9 +2,10 @@ import { acceptClaudeLaunchEnvelope, buildClaudeDispatchRecord, collectClaudeLau
 import { redactAbsolutePaths } from '../../../providers/identity/absolute-paths.js';
 import { CLAUDE_OBSERVATION_SOURCE } from '../../../providers/identity/claude-runtime-observation.js';
 import { CODEX_OBSERVATION_SOURCE } from '../../../providers/identity/codex-runtime-observation.js';
-import { assertNoSensitiveDispatchContent, collectSensitiveDispatchContent, parseGenericDispatchRecord, redactSensitiveValues, } from '../../../providers/identity/generic-dispatch-record.js';
+import { assertNoSensitiveDispatchContent, classifyDispatchOutcome, collectSensitiveDispatchContent, parseGenericDispatchRecord, redactSensitiveValues, } from '../../../providers/identity/generic-dispatch-record.js';
 import { augmentDispatchRecord, compareObservedRuntimeMetadata, comparedObservationAxes, configuredInvocationForObservation, parseRuntimeObservation, safeParseOatDispatchEvidenceEvent, } from '../../../providers/identity/oat-dispatch-record.js';
 import { observationFromFacts, parseRuntimeObservationEnvelope, projectRuntimeObservation, providerSupportsRuntimeObservation, } from '../../../providers/identity/runtime-observation.js';
+import { parseDispatchStamps } from '../../../providers/identity/stamp.js';
 import { ZodError } from 'zod';
 /**
  * Hard redaction boundary. Producers redact their own messages, but this is the
@@ -44,6 +45,233 @@ const OBSERVATION_SOURCE_BY_PROVIDER = {
 const CALLER_ASSERTED_OBSERVATION_SOURCE = 'caller-asserted';
 /** A managed Claude record's provider is derived, and always this value. */
 const MANAGED_CLAUDE_PROVIDER = 'claude';
+/**
+ * One-line journal run record, projection v1.
+ *
+ * An additive rendering of the same validated, redacted record and event: one
+ * line per request id, written by the owning skill under
+ * `## Orchestration Runs` and updated in place with the terminal outcome. The
+ * renderer writes nothing.
+ *
+ * Grammar: `run/v1` followed by named `key=value` fields in the fixed order of
+ * `DISPATCH_RUN_LINE_FIELDS`, joined by ` · `. Inside a value, `\\`, `\·`,
+ * `\~`, `\n` and `\r` escape a backslash, the delimiter, a literal tilde, a
+ * newline and a carriage return; a bare `~` value is null. The configured
+ * identity (`target`, `model`, `effort`) and the observed identity are
+ * separate fields: an observation never replaces the configured invocation.
+ */
+export const DISPATCH_RUN_LINE_PREFIX = 'run/v1';
+export const DISPATCH_RUN_LINE_DELIMITER = ' · ';
+export const DISPATCH_RUN_LINE_FIELDS = [
+    'request',
+    'scope',
+    'action',
+    'role',
+    'target',
+    'model',
+    'effort',
+    'stamp',
+    'launch',
+    'outcome',
+    'terminal',
+    'class',
+    'continuation',
+    'observed',
+    'match',
+];
+const NULL_VALUE = '~';
+function escapeRunLineValue(value) {
+    if (value === null) {
+        return NULL_VALUE;
+    }
+    return value
+        .replaceAll('\\', '\\\\')
+        .replaceAll('·', '\\·')
+        .replaceAll('~', '\\~')
+        .replaceAll('\n', '\\n')
+        .replaceAll('\r', '\\r');
+}
+export function renderDispatchRunLine(fields) {
+    return [
+        DISPATCH_RUN_LINE_PREFIX,
+        ...DISPATCH_RUN_LINE_FIELDS.map((field) => `${field}=${escapeRunLineValue(fields[field])}`),
+    ].join(DISPATCH_RUN_LINE_DELIMITER);
+}
+/**
+ * Split a run line on unescaped delimiters, keeping escapes intact so a bare
+ * `~` (null) stays distinguishable from an escaped `\~` (literal tilde).
+ */
+function splitRunLine(text) {
+    const parts = [];
+    let current = '';
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index];
+        if (character === '\\') {
+            const next = text[index + 1];
+            if (next === undefined) {
+                return null;
+            }
+            current += character + next;
+            index += 1;
+            continue;
+        }
+        if (text.startsWith(DISPATCH_RUN_LINE_DELIMITER, index)) {
+            parts.push(current);
+            current = '';
+            index += DISPATCH_RUN_LINE_DELIMITER.length - 1;
+            continue;
+        }
+        current += character;
+    }
+    parts.push(current);
+    return parts;
+}
+function unescapeRunLineValue(raw) {
+    if (raw === NULL_VALUE) {
+        return null;
+    }
+    let value = '';
+    for (let index = 0; index < raw.length; index += 1) {
+        const character = raw[index];
+        if (character !== '\\') {
+            if (character === '~') {
+                // An unescaped tilde inside a value is not a valid encoding.
+                throw new Error('unescaped ~ inside a value');
+            }
+            value += character;
+            continue;
+        }
+        const next = raw[index + 1];
+        index += 1;
+        if (next === 'n')
+            value += '\n';
+        else if (next === 'r')
+            value += '\r';
+        else if (next === '\\' || next === '·' || next === '~')
+            value += next;
+        else
+            throw new Error(`unknown escape \\${next ?? ''}`);
+    }
+    return value;
+}
+/**
+ * Parse one journal run line (optionally written as a `- ` list item). Every
+ * field must be present exactly once, in order; anything else is malformed.
+ * Callers derive terminality from `launch` and `outcome` with
+ * `classifyDispatchOutcome`, never from the recorded `terminal` text alone.
+ */
+export function parseDispatchRunLine(text) {
+    const body = text.trim().replace(/^[-*][ \t]+/, '');
+    const parts = splitRunLine(body);
+    if (parts == null || parts[0] !== DISPATCH_RUN_LINE_PREFIX) {
+        return {
+            ok: false,
+            reason: `run line must start with ${DISPATCH_RUN_LINE_PREFIX}`,
+        };
+    }
+    const values = parts.slice(1);
+    if (values.length !== DISPATCH_RUN_LINE_FIELDS.length) {
+        return {
+            ok: false,
+            reason: `run line carries ${values.length} fields; ${DISPATCH_RUN_LINE_FIELDS.length} are required`,
+        };
+    }
+    const fields = {};
+    for (const [index, field] of DISPATCH_RUN_LINE_FIELDS.entries()) {
+        const raw = values[index] ?? '';
+        const prefix = `${field}=`;
+        if (!raw.startsWith(prefix)) {
+            return { ok: false, reason: `field ${index + 1} must be ${field}` };
+        }
+        try {
+            fields[field] = unescapeRunLineValue(raw.slice(prefix.length));
+        }
+        catch (error) {
+            return {
+                ok: false,
+                reason: `${field}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    return { ok: true, fields };
+}
+function continuationReference(entry) {
+    if (typeof entry === 'string' || typeof entry === 'number') {
+        return String(entry);
+    }
+    if (!isRecord(entry)) {
+        return null;
+    }
+    for (const key of [
+        'request_id',
+        'requestId',
+        'continuation_event',
+        'event',
+        'event_id',
+        'eventId',
+        'id',
+    ]) {
+        const value = entry[key];
+        if (typeof value === 'string' && value.length > 0) {
+            return value;
+        }
+    }
+    return null;
+}
+/**
+ * Validate a caller-supplied formal `Dispatch:` stamp: one line with the
+ * canonical prefix that parses as a modern stamp. The stamp comes from the
+ * resolver's `dispatchStamp` field; the projection carries it verbatim and
+ * never assembles one.
+ */
+export function assertFormalDispatchStamp(stamp) {
+    if (/[\r\n]/.test(stamp) || !stamp.startsWith('Dispatch: ')) {
+        throw new Error('A dispatch stamp must be one line beginning with the canonical "Dispatch: " prefix.');
+    }
+    const parsed = parseDispatchStamps(stamp);
+    if (parsed.length !== 1 || parsed[0]?.legacy !== false) {
+        throw new Error('A dispatch stamp must be a formal Dispatch: line with scope, action and role fields.');
+    }
+}
+/** Project a validated record result onto the one-line run record. */
+export function projectDispatchRunLine(result, options = {}) {
+    const { record, runtimeIdentity } = result;
+    const classification = classifyDispatchOutcome(record.launch_status, record.child_outcome);
+    const continuation = record.continuation_events
+        .map(continuationReference)
+        .filter((reference) => reference !== null);
+    const observed = runtimeIdentity.observed;
+    const fields = {
+        request: record.request_id,
+        scope: record.scope,
+        action: record.action,
+        role: record.role_name,
+        target: record.role_selector,
+        model: record.model_selector,
+        effort: record.effort_selector,
+        stamp: options.dispatchStamp ?? null,
+        launch: record.launch_status,
+        outcome: record.child_outcome,
+        terminal: classification.terminal ? 'yes' : 'no',
+        class: classification.classification,
+        continuation: continuation.length === 0 ? null : continuation.join(','),
+        observed: observed === null
+            ? null
+            : [
+                observed.provider,
+                observed.model ?? '?',
+                observed.effort ?? '?',
+            ].join('/'),
+        match: runtimeIdentity.match,
+    };
+    return {
+        version: 1,
+        line: renderDispatchRunLine(fields),
+        fields,
+        classification: classification.classification,
+        terminal: classification.terminal,
+    };
+}
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/commands/project/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0BpC,wBAAgB,oBAAoB,IAAI,OAAO,CA0B9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2BpC,wBAAgB,oBAAoB,IAAI,OAAO,CA2B9C"}

package/dist/commands/project/index.js

@@ -6,6 +6,7 @@ import { createProjectCompleteStateCommand } from './complete-state/index.js';
 import { createProjectDeliveryCommand } from './delivery/index.js';
 import { createProjectDispatchCommand } from './dispatch/index.js';
 import { createProjectDispatchCeilingCommand } from './dispatch-ceiling/index.js';
+import { createProjectJournalCommand } from './journal-check/index.js';
 import { createProjectLinksCommand } from './links/index.js';
 import { createProjectListCommand } from './list.js';
 import { createProjectLogCommand } from './log/index.js';
@@ -32,6 +33,7 @@ export function createProjectCommand() {
         .addCommand(createProjectDeliveryCommand())
         .addCommand(createProjectDispatchCommand())
         .addCommand(createProjectDispatchCeilingCommand())
+        .addCommand(createProjectJournalCommand())
         .addCommand(createProjectListCommand())
         .addCommand(createProjectLinksCommand())
         .addCommand(createProjectLogCommand())

package/dist/commands/project/journal-check/evaluator.d.ts

@@ -0,0 +1,17 @@
+import type { JournalCheckInput, JournalCheckResult } from './types.js';
+/**
+ * Evaluate one journal at one lifecycle boundary. Pure and read-only: the
+ * same bytes always give the same result, and nothing is written.
+ *
+ * Task modes (spec-driven, quick, import, lite) use the shared journal record
+ * reader: normalized plan task ids map to unique journal blocks with exactly
+ * one owned terminal status and owned commit evidence or an approved scope
+ * disposition. Brief and goal use the landed phase-unit progress and goal
+ * outcome audit readers; failed, cancelled and no-change execution records
+ * are valid history without a SHA and approved deferrals stay incomplete.
+ * Delivery coverage and the post-implementation sequence stay with the
+ * closeout invariant (`closeout-check`), which `complete-state` evaluates
+ * beside this evaluator.
+ */
+export declare function evaluateJournal(input: JournalCheckInput): JournalCheckResult;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/commands/project/journal-check/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/journal-check/evaluator.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EACV,iBAAiB,EAEjB,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AA6CjB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB,CA4G5E"}

package/dist/commands/project/journal-check/evaluator.js

@@ -0,0 +1,140 @@
+import { parseBriefOutcomes, parseTaskProgress, readFrontmatterMetadata, readJournalRecords, validateGoalOutcomeAudit, } from '@open-agent-toolkit/control-plane';
+import { checkDispatchPayloads, checkMetadata, checkOverviewTotals, checkPhaseUnitRecords, checkReceiptsAndDeferrals, checkReferencesLast, checkRunLines, checkTaskModePhaseStatus, checkTaskModeRecords, checkTemplateResidue, isBriefMode, OVERRIDE_ELIGIBILITY, overrideCoversSubject, readOverrides, } from './rules.js';
+function workflowModeOf(stateRecord) {
+    const mode = stateRecord?.oat_workflow_mode;
+    return typeof mode === 'string' && mode.length > 0 ? mode : 'spec-driven';
+}
+function approvedDeferredPhases(workflowMode, stateRecord, input, progress) {
+    const phases = new Set();
+    if (workflowMode !== 'goal') {
+        return phases;
+    }
+    // Only a valid, exhaustive outcome audit can approve a deferral; an invalid
+    // or missing audit approves nothing (the closeout invariant reports it).
+    const validation = validateGoalOutcomeAudit(stateRecord?.oat_goal_outcome_audit, progress.phases, parseBriefOutcomes(input.planContent));
+    if (!validation.valid || validation.audit === null) {
+        return phases;
+    }
+    for (const [phaseId, entry] of Object.entries(validation.audit.phases)) {
+        if (entry.disposition === 'deferred' || entry.disposition === 'retired') {
+            phases.add(phaseId);
+        }
+    }
+    return phases;
+}
+function toReason(finding) {
+    return {
+        code: finding.code,
+        path: finding.path,
+        line: finding.line,
+        owner: finding.owner,
+        message: finding.message,
+    };
+}
+/**
+ * Evaluate one journal at one lifecycle boundary. Pure and read-only: the
+ * same bytes always give the same result, and nothing is written.
+ *
+ * Task modes (spec-driven, quick, import, lite) use the shared journal record
+ * reader: normalized plan task ids map to unique journal blocks with exactly
+ * one owned terminal status and owned commit evidence or an approved scope
+ * disposition. Brief and goal use the landed phase-unit progress and goal
+ * outcome audit readers; failed, cancelled and no-change execution records
+ * are valid history without a SHA and approved deferrals stay incomplete.
+ * Delivery coverage and the post-implementation sequence stay with the
+ * closeout invariant (`closeout-check`), which `complete-state` evaluates
+ * beside this evaluator.
+ */
+export function evaluateJournal(input) {
+    const journalMeta = readFrontmatterMetadata(input.journalContent);
+    const stateMeta = readFrontmatterMetadata(input.stateContent);
+    const stateRecord = stateMeta.state === 'ok' ? stateMeta.record : null;
+    const workflowMode = workflowModeOf(stateRecord);
+    const briefMode = isBriefMode(workflowMode);
+    const progress = parseTaskProgress(input.planContent, input.journalContent, {
+        phaseUnits: briefMode,
+        extractedUnits: workflowMode === 'goal',
+    });
+    const scope = input.boundary === 'review' && input.scope != null
+        ? [...new Set(input.scope)]
+        : null;
+    const context = {
+        boundary: input.boundary,
+        workflowMode,
+        scope: scope === null ? null : new Set(scope),
+        journal: readJournalRecords(input.journalContent),
+        plan: readJournalRecords(input.planContent),
+        journalMeta,
+        stateMeta,
+        progress,
+        approvedDeferredPhases: approvedDeferredPhases(workflowMode, stateRecord, input, progress),
+        findings: [],
+    };
+    checkMetadata(context, input.stateContent.split('\n'));
+    if (briefMode) {
+        checkPhaseUnitRecords(context);
+    }
+    else {
+        checkTaskModeRecords(context);
+        checkTaskModePhaseStatus(context);
+    }
+    checkOverviewTotals(context);
+    checkReferencesLast(context);
+    checkReceiptsAndDeferrals(context);
+    checkDispatchPayloads(context);
+    checkRunLines(context);
+    checkTemplateResidue(context);
+    const parsedOverrides = readOverrides(context);
+    // Overrides suppress only eligible gaps whose subject the override's scope
+    // covers; nothing else is overridable, and the checker never writes one.
+    const applied = new Set();
+    const remaining = context.findings.filter((finding) => {
+        if (finding.severity !== 'refuse' || finding.subject === undefined) {
+            return true;
+        }
+        const subject = finding.subject;
+        const covering = parsedOverrides.find((override) => OVERRIDE_ELIGIBILITY[override.code].has(finding.code) &&
+            overrideCoversSubject(override, subject));
+        if (covering === undefined) {
+            return true;
+        }
+        applied.add(covering.line);
+        return false;
+    });
+    const overrides = parsedOverrides.map((override) => ({
+        code: override.code,
+        authorizedBy: override.authorizedBy,
+        scope: override.scope,
+        reason: override.reason,
+        line: override.line,
+        applied: applied.has(override.line),
+    }));
+    const warnings = remaining
+        .filter((finding) => finding.severity === 'warn')
+        .map(toReason);
+    for (const override of overrides) {
+        if (!override.applied) {
+            warnings.push({
+                code: 'override-unused',
+                path: 'implementation.md',
+                line: override.line,
+                owner: 'oat-project-complete',
+                message: `Override ${override.code} for ${override.scope} covers no eligible gap.`,
+            });
+        }
+    }
+    const reasons = remaining
+        .filter((finding) => finding.severity === 'refuse')
+        .map(toReason)
+        .sort((left, right) => (left.line ?? Number.MAX_SAFE_INTEGER) -
+        (right.line ?? Number.MAX_SAFE_INTEGER));
+    return {
+        status: reasons.length === 0 ? 'ok' : 'refused',
+        boundary: input.boundary,
+        workflowMode,
+        scope,
+        reasons,
+        warnings,
+        overrides,
+    };
+}

package/dist/commands/project/journal-check/index.d.ts

@@ -0,0 +1,34 @@
+import { type CommandContext, type GlobalOptions } from '../../../app/command-context.js';
+import { type ActiveProjectResolution } from '../../../config/oat-config.js';
+import { Command } from 'commander';
+import { type JournalCheckReason, type JournalCheckResult } from './types.js';
+export { evaluateJournal } from './evaluator.js';
+export type { JournalCheckBoundary, JournalCheckReason, JournalCheckResult, } from './types.js';
+export interface JournalCheckFiles {
+    planContent: string;
+    journalContent: string;
+    stateContent: string;
+}
+export interface JournalCheckDependencies {
+    buildCommandContext: (options: GlobalOptions) => CommandContext;
+    resolveProjectRoot: (cwd: string) => Promise<string>;
+    resolveActiveProject: (repoRoot: string) => Promise<ActiveProjectResolution>;
+    readFile: (path: string, encoding: 'utf8') => Promise<string>;
+    dirExists: (path: string) => Promise<boolean>;
+    fileExists: (path: string) => Promise<boolean>;
+}
+/**
+ * Read the three inputs the evaluator needs. A missing journal or plan is a
+ * command error, never an empty file: an unreadable input must not read as a
+ * valid journal.
+ */
+export declare function readJournalCheckFiles(projectDir: string, dependencies: Pick<JournalCheckDependencies, 'readFile' | 'fileExists'>): Promise<JournalCheckFiles>;
+/**
+ * Parse `--scope pNN[,pNN]` into normalized phase ids, each of which must name
+ * a phase the plan declares.
+ */
+export declare function parseJournalScope(raw: string, planContent: string, workflowMode: 'task' | 'phase-unit'): string[];
+export declare function formatJournalReason(reason: JournalCheckReason): string;
+export declare function formatJournalRefusal(projectPath: string, result: JournalCheckResult): string;
+export declare function createProjectJournalCommand(overrides?: Partial<JournalCheckDependencies>): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/project/journal-check/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/journal-check/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAS5B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACxB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EACV,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;IAChE,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,oBAAoB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC7E,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9D,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9C,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD;AAWD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,IAAI,CAAC,wBAAwB,EAAE,UAAU,GAAG,YAAY,CAAC,GACtE,OAAO,CAAC,iBAAiB,CAAC,CAa5B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GAAG,YAAY,GAClC,MAAM,EAAE,CAuBV;AASD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAItE;AAED,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,kBAAkB,GACzB,MAAM,CAKR;AAwGD,wBAAgB,2BAA2B,CACzC,SAAS,GAAE,OAAO,CAAC,wBAAwB,CAAM,GAChD,OAAO,CAiCT"}

package/dist/commands/project/journal-check/index.js

@@ -0,0 +1,163 @@
+import { readFile as defaultReadFile } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
+import { buildCommandContext, } from '../../../app/command-context.js';
+import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { resolveActiveProject, } from '../../../config/oat-config.js';
+import { CliError } from '../../../errors/cli-error.js';
+import { dirExists, fileExists } from '../../../fs/io.js';
+import { resolveProjectRoot } from '../../../fs/paths.js';
+import { normalizePhaseId, parseTaskProgress, readFrontmatterMetadata, } from '@open-agent-toolkit/control-plane';
+import { Command } from 'commander';
+import { evaluateJournal } from './evaluator.js';
+import { JOURNAL_CHECK_BOUNDARIES, } from './types.js';
+export { evaluateJournal } from './evaluator.js';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveActiveProject,
+    readFile: (path, encoding) => defaultReadFile(path, encoding),
+    dirExists,
+    fileExists,
+};
+/**
+ * Read the three inputs the evaluator needs. A missing journal or plan is a
+ * command error, never an empty file: an unreadable input must not read as a
+ * valid journal.
+ */
+export async function readJournalCheckFiles(projectDir, dependencies) {
+    const read = async (name) => {
+        const path = join(projectDir, name);
+        if (!(await dependencies.fileExists(path))) {
+            throw new CliError(`Project ${name} not found: ${path}`, 1);
+        }
+        return dependencies.readFile(path, 'utf8');
+    };
+    return {
+        planContent: await read('plan.md'),
+        journalContent: await read('implementation.md'),
+        stateContent: await read('state.md'),
+    };
+}
+/**
+ * Parse `--scope pNN[,pNN]` into normalized phase ids, each of which must name
+ * a phase the plan declares.
+ */
+export function parseJournalScope(raw, planContent, workflowMode) {
+    const tokens = raw
+        .split(',')
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        throw new CliError('--scope needs at least one phase id (pNN).', 1);
+    }
+    const declared = new Set(parseTaskProgress(planContent, '', {
+        phaseUnits: workflowMode === 'phase-unit',
+    }).phases.map((phase) => phase.phaseId));
+    return tokens.map((token) => {
+        const phaseId = normalizePhaseId(token);
+        if (phaseId === null) {
+            throw new CliError(`--scope ${token} is not a phase id (pNN).`, 1);
+        }
+        if (!declared.has(phaseId)) {
+            throw new CliError(`--scope ${token} names no phase in plan.md.`, 1);
+        }
+        return phaseId;
+    });
+}
+function readWorkflowMode(stateContent) {
+    const metadata = readFrontmatterMetadata(stateContent);
+    const mode = metadata.state === 'ok' ? metadata.record.oat_workflow_mode : undefined;
+    return typeof mode === 'string' && mode.length > 0 ? mode : 'spec-driven';
+}
+export function formatJournalReason(reason) {
+    const location = reason.line === null ? reason.path : `${reason.path}:${reason.line}`;
+    return `${reason.code} ${location} (${reason.owner}): ${reason.message}`;
+}
+export function formatJournalRefusal(projectPath, result) {
+    return [
+        `Journal check refused ${projectPath} at ${result.boundary} (${result.reasons.length} reason${result.reasons.length === 1 ? '' : 's'}):`,
+        ...result.reasons.map((reason) => `- ${formatJournalReason(reason)}`),
+    ].join('\n');
+}
+async function resolveProjectDir(options, repoRoot, dependencies) {
+    if (options.project) {
+        const projectDir = isAbsolute(options.project)
+            ? resolve(options.project)
+            : resolve(repoRoot, options.project);
+        if (!(await dependencies.dirExists(projectDir)) ||
+            !(await dependencies.fileExists(join(projectDir, 'state.md')))) {
+            throw new CliError(`Project path is missing or invalid: ${options.project}. Pass --project <path> for a directory containing state.md.`, 1);
+        }
+        return projectDir;
+    }
+    const active = await dependencies.resolveActiveProject(repoRoot);
+    if (active.status !== 'active' || !active.path) {
+        throw new CliError('No active project resolves. Set activeProject or pass --project <path>.', 1);
+    }
+    return resolve(repoRoot, active.path);
+}
+async function runJournalCheck(options, context, dependencies) {
+    try {
+        const boundary = options.at;
+        if (boundary === undefined ||
+            !JOURNAL_CHECK_BOUNDARIES.includes(boundary)) {
+            throw new CliError(`--at must be one of ${JOURNAL_CHECK_BOUNDARIES.join(', ')}.`, 1);
+        }
+        if (boundary === 'review' && !options.scope) {
+            throw new CliError('--at review needs an explicit --scope pNN[,pNN].', 1);
+        }
+        if (boundary !== 'review' && options.scope) {
+            throw new CliError('--scope applies only to --at review.', 1);
+        }
+        const repoRoot = await dependencies.resolveProjectRoot(context.cwd);
+        const projectDir = await resolveProjectDir(options, repoRoot, dependencies);
+        const files = await readJournalCheckFiles(projectDir, dependencies);
+        const workflowMode = readWorkflowMode(files.stateContent);
+        const scope = boundary === 'review' && options.scope
+            ? parseJournalScope(options.scope, files.planContent, workflowMode === 'brief' || workflowMode === 'goal'
+                ? 'phase-unit'
+                : 'task')
+            : null;
+        const result = evaluateJournal({ boundary, scope, ...files });
+        if (context.json) {
+            context.logger.json({ ...result, projectPath: projectDir });
+        }
+        else if (result.status === 'ok') {
+            context.logger.info(`Journal check passed at ${boundary}${scope === null ? '' : ` for ${scope.join(', ')}`}.`);
+            for (const warning of result.warnings) {
+                context.logger.warn(`warning: ${formatJournalReason(warning)}`);
+            }
+        }
+        else {
+            context.logger.info(formatJournalRefusal(projectDir, result));
+            for (const warning of result.warnings) {
+                context.logger.warn(`warning: ${formatJournalReason(warning)}`);
+            }
+        }
+        process.exitCode = result.status === 'ok' ? 0 : 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (context.json) {
+            context.logger.json({ status: 'error', message });
+        }
+        else {
+            context.logger.error(message);
+        }
+        process.exitCode = error instanceof CliError ? error.exitCode : 1;
+    }
+}
+export function createProjectJournalCommand(overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    return new Command('journal')
+        .description('Validate the implementation journal (read-only)')
+        .addCommand(new Command('check')
+        .description('Evaluate implementation.md against plan.md and state.md at one lifecycle boundary (writes nothing)')
+        .option('--project <path>', 'Project directory (defaults to the active project)')
+        .option('--at <boundary>', 'Boundary: implement-preflight, review, or completion')
+        .option('--scope <phases>', 'Review only: comma-separated phase ids to check (pNN[,pNN])')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        await runJournalCheck(options, context, dependencies);
+    }));
+}