@event4u/agent-config 8.8.0 → 8.10.0

package/src/scripts/_lib/claude_builtin_names.ts

@@ -0,0 +1,148 @@
+// Claude Code built-in command / bundled-skill names — the reserved namespace.
+//
+// A user- or project-scope skill (or flat command) whose name equals a
+// built-in Claude Code slash command SHADOWS the built-in: typing `/mcp`
+// then opens the package's skill instead of Claude Code's MCP auth dialog
+// (observed 2026-07-10). The suite's contract is to complement the host,
+// never to overlay or degrade it — so no Claude-facing projection may claim
+// one of these names.
+//
+// Enforced at three layers:
+//   1. `condense.ts::generate_claude_commands` — project-scope `.claude/skills/`
+//      command entries skip reserved slugs.
+//   2. `install.ts::_apply_claude_flat_command_wrappers` — user-scope
+//      `~/.claude/` deploys neither a skill wrapper nor a flat command file
+//      for a reserved slug (nested `/cluster:sub` commands are unaffected —
+//      built-ins carry no `:`).
+//   3. `lint_agent_skill_names.ts` — a skill in `src/skills/` (or a domain
+//      pack) with a reserved name fails CI unless it opts out of slash
+//      registration with `user-invocable: false` (Claude may still load it
+//      automatically; the built-in keeps the `/name`).
+//
+// Source: https://code.claude.com/docs/en/commands (fetched 2026-07-10),
+// plus a small legacy set still present in older Claude Code versions.
+// Refresh trigger: a package artefact stops appearing in Claude Code, or a
+// release-notes entry adds a new built-in command.
+
+const _CURRENT = [
+    'add-dir',
+    'advisor',
+    'agents',
+    'autofix-pr',
+    'background',
+    'batch',
+    'branch',
+    'btw',
+    'cd',
+    'chrome',
+    'claude-api',
+    'clear',
+    'code-review',
+    'color',
+    'compact',
+    'config',
+    'context',
+    'copy',
+    'cost',
+    'dataviz',
+    'debug',
+    'deep-research',
+    'design-login',
+    'design-sync',
+    'desktop',
+    'diff',
+    'doctor',
+    'effort',
+    'exit',
+    'export',
+    'fast',
+    'feedback',
+    'fewer-permission-prompts',
+    'focus',
+    'fork',
+    'goal',
+    'heapdump',
+    'help',
+    'hooks',
+    'ide',
+    'init',
+    'insights',
+    'install-github-app',
+    'install-slack-app',
+    'keybindings',
+    'login',
+    'logout',
+    'loop',
+    'mcp',
+    'memory',
+    'mobile',
+    'model',
+    'passes',
+    'permissions',
+    'plan',
+    'plugin',
+    'powerup',
+    'pr-comments',
+    'privacy-settings',
+    'radio',
+    'recap',
+    'release-notes',
+    'reload-plugins',
+    'reload-skills',
+    'remote-control',
+    'remote-env',
+    'rename',
+    'resume',
+    'review',
+    'rewind',
+    'run',
+    'run-skill-generator',
+    'sandbox',
+    'schedule',
+    'scroll-speed',
+    'security-review',
+    'setup-bedrock',
+    'setup-vertex',
+    'simplify',
+    'skills',
+    'stats',
+    'status',
+    'statusline',
+    'stickers',
+    'teleport',
+    'thinking',
+    'trust',
+    'upgrade',
+    'usage',
+    'verify',
+    'vim',
+    'web',
+    'whats-new',
+    'workflow',
+    'workflows',
+    'worktree',
+] as const;
+
+// Retired from the current docs but still registered by older Claude Code
+// versions users may run — reserving them costs nothing (no package artefact
+// uses these names) and avoids version-dependent shadowing.
+const _LEGACY = [
+    'bashes',
+    'bug',
+    'migrate-installer',
+    'output-style',
+    'terminal-setup',
+    'theme',
+    'todos',
+] as const;
+
+/** Lowercase names a Claude-facing `/name` projection must never claim. */
+export const CLAUDE_CODE_BUILTIN_NAMES: ReadonlySet<string> = new Set<string>([
+    ..._CURRENT,
+    ..._LEGACY,
+]);
+
+/** True when `slug` would shadow a Claude Code built-in command or bundled skill. */
+export function is_claude_builtin_name(slug: string): boolean {
+    return CLAUDE_CODE_BUILTIN_NAMES.has(slug.toLowerCase());
+}

package/src/scripts/_lib/file_slicer.ts

@@ -0,0 +1,117 @@
+/**
+ * Deterministic document slicer for oversized knowledge ingest
+ * (road-to-retrieval-substrate-hardening B8).
+ *
+ * Splits a large markdown document into bounded slices at the cleanest
+ * available boundary — heading > paragraph (blank line) > line — while
+ * guaranteeing three invariants a downstream re-assembler can rely on:
+ *
+ *   1. GAP-FREE + NON-OVERLAPPING — slices cover contiguous line ranges over
+ *      the whole document, in order.
+ *   2. CONCAT == ORIGINAL — joining every slice's `text` in order reproduces
+ *      the input byte-for-byte (slices are exact offset ranges).
+ *   3. PARENTED — every slice carries its source `parentPath` (when given) and
+ *      its `[startLine, endLine)` range, so a chunk can point home.
+ *
+ * Deterministic: identical input + budget → identical slices.
+ */
+
+export interface Slice {
+    parentPath: string | null;
+    index: number;
+    startLine: number; // 0-based, inclusive
+    endLine: number; // 0-based, exclusive
+    text: string;
+}
+
+/** Default per-slice character budget. */
+export const DEFAULT_MAX_CHARS = 2000;
+
+function _lineStartOffsets(text: string): number[] {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '\n') starts.push(i + 1);
+    }
+    return starts; // one entry per line; starts[k] = offset where line k begins
+}
+
+function _isHeading(line: string): boolean {
+    return /^#{1,6}\s/.test(line);
+}
+function _isBlank(line: string): boolean {
+    return line.trim() === '';
+}
+
+/**
+ * Slice `text` into ≤ `maxChars` pieces (best-effort — a single over-long line
+ * is emitted whole rather than split mid-line, preserving invariant 2).
+ * `parentPath` is stamped on every slice.
+ */
+export function sliceDocument(
+    text: string,
+    opts: { maxChars?: number; parentPath?: string } = {},
+): Slice[] {
+    const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
+    const parentPath = opts.parentPath ?? null;
+    if (text === '') return [];
+
+    const starts = _lineStartOffsets(text);
+    const nLines = starts.length;
+    // lineAt(k) = the raw text of line k INCLUDING its trailing newline (if any).
+    const lineEnd = (k: number): number => (k + 1 < nLines ? starts[k + 1]! : text.length);
+    const lines: string[] = [];
+    for (let k = 0; k < nLines; k++) lines.push(text.slice(starts[k]!, lineEnd(k)));
+
+    const slices: Slice[] = [];
+    let sliceStartLine = 0;
+    let idx = 0;
+    const flush = (endLine: number): void => {
+        if (endLine <= sliceStartLine) return;
+        const from = starts[sliceStartLine]!;
+        const to = endLine < nLines ? starts[endLine]! : text.length;
+        slices.push({ parentPath, index: idx++, startLine: sliceStartLine, endLine, text: text.slice(from, to) });
+        sliceStartLine = endLine;
+    };
+
+    let curChars = 0;
+    for (let k = 0; k < nLines; k++) {
+        const lineLen = lines[k]!.length;
+        const wouldExceed = curChars + lineLen > maxChars && k > sliceStartLine;
+        // Cut BEFORE a heading that opens a new section (clean boundary), or
+        // when the budget would overflow — preferring a preceding blank line.
+        const headingBoundary = _isHeading(lines[k]!) && k > sliceStartLine;
+        if (headingBoundary || wouldExceed) {
+            // Prefer to end the previous slice at the last blank line in-range,
+            // so a slice ends on a paragraph boundary when one is available.
+            let cut = k;
+            if (wouldExceed && !headingBoundary) {
+                for (let b = k - 1; b > sliceStartLine; b--) {
+                    if (_isBlank(lines[b]!)) {
+                        cut = b + 1;
+                        break;
+                    }
+                }
+            }
+            flush(cut);
+            curChars = 0;
+            for (let j = sliceStartLine; j <= k; j++) curChars += lines[j]!.length;
+        } else {
+            curChars += lineLen;
+        }
+    }
+    flush(nLines);
+    return slices;
+}
+
+/** True iff the slices reproduce `text` exactly, gap-free and non-overlapping. */
+export function verifySlices(text: string, slices: readonly Slice[]): boolean {
+    if (slices.length === 0) return text === '';
+    let expectedLine = 0;
+    const parts: string[] = [];
+    for (const s of slices) {
+        if (s.startLine !== expectedLine) return false; // gap or overlap
+        expectedLine = s.endLine;
+        parts.push(s.text);
+    }
+    return parts.join('') === text;
+}

package/src/scripts/_lib/lexical_index.ts

@@ -0,0 +1,155 @@
+/**
+ * Hand-rolled, dependency-free lexical index for memory/knowledge retrieval
+ * (road-to-retrieval-substrate-hardening B2).
+ *
+ * The current `memory_lookup._score` gives every keyword match the SAME coarse
+ * bucket (0.8 glob / 0.6 substring), so several entries tie at the top and
+ * retrieval "recalls but does not rank" (the mean-tie-set 3.3 finding from
+ * road-to-second-brain-retrieval-precision). This module replaces that bucket
+ * with a continuous BM25 score over an IDF-weighted term index, plus a
+ * character-trigram candidate prefilter so it stays cheap at corpus scale.
+ *
+ * It is the BM25 core ADR-061 already sanctions — pure Node stdlib, NO engine
+ * fork, NO minisearch-class dependency. `_score` stays as the below-tripwire
+ * mini-corpus fallback; this index activates at the `lint_knowledge_scale`
+ * tripwire. Deterministic: identical docs + query → identical scores + order.
+ */
+
+/** BM25 term-frequency saturation. */
+export const BM25_K1 = 1.5;
+/** BM25 length-normalisation strength. */
+export const BM25_B = 0.75;
+/** Minimum token length kept (drops single chars / punctuation noise). */
+export const MIN_TOKEN_LEN = 2;
+
+export interface IndexDoc {
+    id: string;
+    /** All searchable text of the entry, already concatenated. */
+    text: string;
+}
+
+interface DocStats {
+    id: string;
+    len: number; // token count
+    tf: Map<string, number>; // term → frequency in this doc
+    trigrams: Set<string>;
+}
+
+/** Lowercase, split on non-alphanumeric, keep tokens ≥ MIN_TOKEN_LEN. */
+export function tokenize(s: string): string[] {
+    const out: string[] = [];
+    for (const raw of s.toLowerCase().split(/[^a-z0-9]+/)) {
+        if (raw.length >= MIN_TOKEN_LEN) out.push(raw);
+    }
+    return out;
+}
+
+/** Character trigrams of a normalised string (alphanumerics + single spaces). */
+export function trigrams(s: string): Set<string> {
+    const norm = s.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+    const out = new Set<string>();
+    if (norm.length < 3) {
+        if (norm.length > 0) out.add(norm);
+        return out;
+    }
+    for (let i = 0; i + 3 <= norm.length; i++) {
+        out.add(norm.slice(i, i + 3));
+    }
+    return out;
+}
+
+/**
+ * An in-memory BM25 index over a fixed document set. Built once, queried many
+ * times. Stateless after construction — `rank()` / `score()` never mutate it,
+ * so a cached instance is safe to reuse until the underlying corpus changes.
+ */
+export class LexicalIndex {
+    private readonly docs: Map<string, DocStats> = new Map();
+    private readonly df: Map<string, number> = new Map();
+    private readonly n: number;
+    private readonly avgdl: number;
+
+    constructor(documents: readonly IndexDoc[]) {
+        let totalLen = 0;
+        for (const d of documents) {
+            const tokens = tokenize(d.text);
+            const tf = new Map<string, number>();
+            for (const t of tokens) tf.set(t, (tf.get(t) ?? 0) + 1);
+            for (const t of tf.keys()) this.df.set(t, (this.df.get(t) ?? 0) + 1);
+            this.docs.set(d.id, { id: d.id, len: tokens.length, tf, trigrams: trigrams(d.text) });
+            totalLen += tokens.length;
+        }
+        this.n = documents.length;
+        this.avgdl = this.n > 0 ? totalLen / this.n : 0;
+    }
+
+    /** Robertson–Spärck-Jones IDF, floored at 0 so common terms never subtract. */
+    private idf(term: string): number {
+        const df = this.df.get(term) ?? 0;
+        if (df === 0) return 0;
+        return Math.max(0, Math.log(1 + (this.n - df + 0.5) / (df + 0.5)));
+    }
+
+    /** BM25 score of one document against the tokenised query terms. */
+    score(queryTerms: readonly string[], docId: string): number {
+        const doc = this.docs.get(docId);
+        if (doc === undefined || doc.len === 0) return 0;
+        let s = 0;
+        for (const term of queryTerms) {
+            const tf = doc.tf.get(term);
+            if (tf === undefined) continue;
+            const idf = this.idf(term);
+            if (idf === 0) continue;
+            const denom = tf + BM25_K1 * (1 - BM25_B + (BM25_B * doc.len) / (this.avgdl || 1));
+            s += (idf * (tf * (BM25_K1 + 1))) / denom;
+        }
+        return s;
+    }
+
+    /**
+     * Rank documents for a set of query keys (phrases are tokenised). A
+     * character-trigram prefilter selects candidates cheaply; the guard keeps
+     * any doc sharing a query TOKEN even when no trigram overlaps, so the
+     * prefilter never drops a genuine lexical match. Ties break by id for a
+     * stable, deterministic order.
+     */
+    rank(queryKeys: readonly string[]): Array<{ id: string; score: number }> {
+        const queryText = queryKeys.join(' ');
+        const qTerms = tokenize(queryText);
+        const qTermSet = new Set(qTerms);
+        const qTrigrams = trigrams(queryText);
+
+        const candidates: string[] = [];
+        for (const [id, doc] of this.docs) {
+            let hit = false;
+            for (const t of qTrigrams) {
+                if (doc.trigrams.has(t)) {
+                    hit = true;
+                    break;
+                }
+            }
+            if (!hit) {
+                // Guard: keep a doc that shares an exact query token even with
+                // no trigram overlap (short tokens / edge normalisation).
+                for (const t of qTermSet) {
+                    if (doc.tf.has(t)) {
+                        hit = true;
+                        break;
+                    }
+                }
+            }
+            if (hit) candidates.push(id);
+        }
+
+        const scored = candidates
+            .map((id) => ({ id, score: this.score(qTerms, id) }))
+            .filter((r) => r.score > 0);
+        scored.sort((a, b) => (b.score - a.score) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        return scored;
+    }
+
+    /** Document count — for the caller's tripwire / diagnostics. */
+    get size(): number {
+        return this.n;
+    }
+}

package/src/scripts/_lib/orchestration_record.ts

@@ -0,0 +1,183 @@
+/**
+ * Orchestration telemetry record builder (pure, no-I/O).
+ *
+ * Builds ONE validated audit-log-v1 line carrying an `orchestration`
+ * sub-object, from the counts the orchestrating agent already has after an
+ * auto-dispatch. This is the agent-behavioral capture path decided 2026-06-30
+ * (maintainer decision: no hook/daemon — the agent writes directly), made
+ * reliable + one-command here instead of hand-authored JSON.
+ *
+ * Contracts:
+ * - `docs/contracts/audit-log-v1.md` (the envelope)
+ * - `src/agent-src/contexts/execution/orchestration-telemetry.md` (the object)
+ *
+ * PRIVACY BY CONSTRUCTION: every field is a count, enum, or id — there is NO
+ * field capable of holding free-form content, prompt text, or a body. Do not
+ * add one. (Mirrors `domain-safety-pii` § Surface 2 / artifact-engagement.)
+ */
+
+export type DispatchOutcome = 'DONE' | 'DONE_WITH_CONCERNS' | 'NEEDS_CONTEXT' | 'BLOCKED' | 'killed';
+export type VerifyMode = 'deterministic' | 'judge' | 'none';
+export type Provenance = 'measured' | 'estimated';
+export type TierChosen = 'lite' | 'medium' | 'high';
+export type TierSource = 'static' | 'inferred' | 'inherit';
+export type Band = 'low' | 'medium' | 'high';
+export type LinePhase = 'refine' | 'memory' | 'analyze' | 'plan' | 'implement' | 'test' | 'verify' | 'report';
+export type LineOutcome = 'success' | 'blocked' | 'skipped' | 'error';
+
+/** Inputs the agent supplies about one auto-dispatch. */
+export interface RecordInput {
+    // Orchestration object
+    spawn_count: number;
+    token_delta: number;
+    // Optionals accept explicit `undefined` (CLI parsing yields it); the
+    // builder defaults every one. Compatible with exactOptionalPropertyTypes.
+    token_delta_provenance?: Provenance | undefined;
+    tiers?: string[] | undefined;
+    tier_chosen?: TierChosen | null | undefined;
+    tier_source?: TierSource | null | undefined;
+    task_class?: string | null | undefined;
+    task_size_estimate?: number | undefined;
+    wall_clock_ms?: number | undefined;
+    /** Absolute measured tokens the dispatched slice consumed (feeds the modeled cost-%). */
+    dispatch_tokens?: number | null | undefined;
+    /** The orchestrator's own tier — the baseline the downshift cost-% measures against. */
+    session_tier?: string | null | undefined;
+    dispatch_outcome?: DispatchOutcome | undefined;
+    verify_mode?: VerifyMode | undefined;
+    /** QUALITY: subagent return adopted without parent rework. Optional boolean (null = not measured). */
+    first_pass_success?: boolean | undefined;
+    /** QUALITY: slice retried on a higher tier after a verification failure. Optional boolean (null = not measured). */
+    escalated?: boolean | undefined;
+    // Audit-log envelope (sensible defaults for a dispatch record)
+    phase?: LinePhase | undefined;
+    outcome?: LineOutcome | undefined;
+    confidence_band?: Band | undefined;
+    risk_class?: Band | undefined;
+    persona?: string | null | undefined;
+    work_id?: string | undefined;
+    /** ISO-8601 UTC timestamp; caller supplies (keeps this fn pure/deterministic). */
+    ts: string;
+    /** Stable id (ULID or content hash); caller supplies. */
+    id: string;
+}
+
+export interface BuiltLine {
+    line: Record<string, unknown> | null;
+    errors: string[];
+}
+
+const DISPATCH_OUTCOMES: readonly DispatchOutcome[] = ['DONE', 'DONE_WITH_CONCERNS', 'NEEDS_CONTEXT', 'BLOCKED', 'killed'];
+const VERIFY_MODES: readonly VerifyMode[] = ['deterministic', 'judge', 'none'];
+const PROVENANCES: readonly Provenance[] = ['measured', 'estimated'];
+const TIERS_CHOSEN: readonly TierChosen[] = ['lite', 'medium', 'high'];
+const TIER_SOURCES: readonly TierSource[] = ['static', 'inferred', 'inherit'];
+const BANDS: readonly Band[] = ['low', 'medium', 'high'];
+const PHASES: readonly LinePhase[] = ['refine', 'memory', 'analyze', 'plan', 'implement', 'test', 'verify', 'report'];
+
+/** Map a dispatch outcome to the audit-log envelope outcome enum. */
+function envelopeOutcome(d: DispatchOutcome): LineOutcome {
+    if (d === 'BLOCKED') return 'blocked';
+    if (d === 'NEEDS_CONTEXT') return 'skipped';
+    if (d === 'killed') return 'error';
+    return 'success'; // DONE / DONE_WITH_CONCERNS
+}
+
+function isInt(n: unknown): n is number {
+    return typeof n === 'number' && Number.isFinite(n) && Number.isInteger(n);
+}
+
+/**
+ * Build + validate the audit-log-v1 line. Returns `{line, errors}`; when
+ * `errors` is non-empty, `line` is null and the caller must NOT write.
+ */
+export function buildOrchestrationLine(input: RecordInput): BuiltLine {
+    const errors: string[] = [];
+
+    if (!isInt(input.spawn_count) || input.spawn_count < 1) {
+        errors.push('spawn_count must be an integer ≥ 1 (0 = handled in-session, not a dispatch — do not record)');
+    }
+    if (!isInt(input.token_delta)) errors.push('token_delta must be an integer (negative = net saved vs the in-session baseline)');
+    if (input.task_size_estimate !== undefined && (!isInt(input.task_size_estimate) || input.task_size_estimate < 0)) {
+        errors.push('task_size_estimate must be a non-negative integer');
+    }
+    if (input.wall_clock_ms !== undefined && (!isInt(input.wall_clock_ms) || input.wall_clock_ms < 0)) {
+        errors.push('wall_clock_ms must be a non-negative integer');
+    }
+    if (input.dispatch_tokens != null && (!isInt(input.dispatch_tokens) || input.dispatch_tokens < 0)) {
+        errors.push('dispatch_tokens must be a non-negative integer (absolute tokens the dispatched slice consumed)');
+    }
+
+    const prov: Provenance = input.token_delta_provenance ?? 'estimated';
+    if (!PROVENANCES.includes(prov)) errors.push(`token_delta_provenance must be one of ${PROVENANCES.join(' | ')}`);
+
+    const dOutcome: DispatchOutcome = input.dispatch_outcome ?? 'DONE';
+    if (!DISPATCH_OUTCOMES.includes(dOutcome)) errors.push(`dispatch_outcome must be one of ${DISPATCH_OUTCOMES.join(' | ')}`);
+
+    const vMode: VerifyMode = input.verify_mode ?? 'deterministic';
+    if (!VERIFY_MODES.includes(vMode)) errors.push(`verify_mode must be one of ${VERIFY_MODES.join(' | ')}`);
+
+    if (input.tier_chosen != null && !TIERS_CHOSEN.includes(input.tier_chosen)) {
+        errors.push(`tier_chosen must be one of ${TIERS_CHOSEN.join(' | ')} (or omitted)`);
+    }
+    if (input.tier_source != null && !TIER_SOURCES.includes(input.tier_source)) {
+        errors.push(`tier_source must be one of ${TIER_SOURCES.join(' | ')} (or omitted)`);
+    }
+
+    const band = input.confidence_band ?? 'medium';
+    if (!BANDS.includes(band)) errors.push(`confidence_band must be one of ${BANDS.join(' | ')}`);
+    const risk = input.risk_class ?? 'low';
+    if (!BANDS.includes(risk)) errors.push(`risk_class must be one of ${BANDS.join(' | ')}`);
+    const phase = input.phase ?? 'implement';
+    if (!PHASES.includes(phase)) errors.push(`phase must be one of ${PHASES.join(' | ')}`);
+
+    if (input.first_pass_success !== undefined && typeof input.first_pass_success !== 'boolean') {
+        errors.push('first_pass_success must be a boolean (true = return adopted without parent rework) or omitted');
+    }
+    if (input.escalated !== undefined && typeof input.escalated !== 'boolean') {
+        errors.push('escalated must be a boolean (true = retried on a higher tier after verification failure) or omitted');
+    }
+
+    if (!input.ts) errors.push('ts (ISO-8601 UTC) is required');
+    if (!input.id) errors.push('id (ULID or content hash) is required');
+
+    if (errors.length) return { line: null, errors };
+
+    const orchestration: Record<string, unknown> = {
+        task_size_estimate: input.task_size_estimate ?? 0,
+        spawn_count: input.spawn_count,
+        tiers: input.tiers ?? [],
+        token_delta: input.token_delta,
+        token_delta_provenance: prov,
+        wall_clock_ms: input.wall_clock_ms ?? 0,
+        outcome: dOutcome,
+        verify_mode: vMode,
+        task_class: input.task_class ?? null,
+        tier_chosen: input.tier_chosen ?? null,
+        tier_source: input.tier_source ?? null,
+        dispatch_tokens: input.dispatch_tokens ?? null,
+        session_tier: input.session_tier ?? null,
+        first_pass_success: input.first_pass_success ?? null,
+        escalated: input.escalated ?? null,
+    };
+
+    const line: Record<string, unknown> = {
+        schema_version: 1,
+        id: input.id,
+        ts: input.ts,
+        work_id: input.work_id ?? `orchestration-${input.ts}`,
+        phase,
+        outcome: input.outcome ?? envelopeOutcome(dOutcome),
+        confidence_band: band,
+        risk_class: risk,
+        memory: { asks: 0, hits: 0 },
+        verify: { claims: 0, first_try_passes: 0 },
+        rules_applied: ['delegation-policy'],
+        persona: input.persona ?? null,
+        input_kind: 'orchestration',
+        type: 'phase',
+        orchestration,
+    };
+
+    return { line, errors: [] };
+}