code-ai-installer 4.0.0 → 4.0.1-a

package/dist/mcp/proposal_dedup.d.ts

@@ -0,0 +1,32 @@
+import { type DomainId } from "../shared/index.js";
+export interface SkillMeta {
+    name: string;
+    topic: string[];
+    tech: string[];
+    related: string[];
+}
+export interface DedupOverlap {
+    skill: string;
+    reasons: string[];
+}
+/**
+ * Read each SKILL.md frontmatter in a domain (name + topic/tech/related). Narrow reader — it does
+ * NOT change list_skills' public contract; 4c just needs fields list_skills doesn't surface.
+ * Tolerant: a folder without SKILL.md or with bad frontmatter is skipped.
+ */
+export declare function readDomainSkillMeta(domain: DomainId): Promise<SkillMeta[]>;
+/**
+ * Overlap of an additive (new-skill) proposal against existing domain skills (ADR-DEV-125, Plan A).
+ * Pure + deterministic — callers inject the skill list (readDomainSkillMeta in prod, fixtures in tests).
+ *
+ * A skill is flagged when ANY of:
+ *   - exact name match, OR
+ *   - shares a name token AND a vocab term with the skill's topic/tech, OR
+ *   - near-duplicate name (one name contains the other), OR
+ *   - the skill's related[] already lists the proposed name.
+ */
+export declare function findOverlaps(args: {
+    proposalName: string;
+    text: string;
+    skills: SkillMeta[];
+}): DedupOverlap[];

package/dist/mcp/proposal_dedup.js

@@ -0,0 +1,102 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { SkillFrontmatter, TechSeed, TopicSeed } from "../shared/index.js";
+import { resolveSkillsRoot } from "./paths.js";
+/**
+ * Read each SKILL.md frontmatter in a domain (name + topic/tech/related). Narrow reader — it does
+ * NOT change list_skills' public contract; 4c just needs fields list_skills doesn't surface.
+ * Tolerant: a folder without SKILL.md or with bad frontmatter is skipped.
+ */
+export async function readDomainSkillMeta(domain) {
+    const root = resolveSkillsRoot(domain);
+    const dirs = await readdir(root, { withFileTypes: true }).catch(() => []);
+    const out = [];
+    for (const d of dirs) {
+        if (!d.isDirectory())
+            continue;
+        const raw = await readFile(join(root, d.name, "SKILL.md"), "utf8").catch(() => null);
+        if (!raw)
+            continue;
+        const stripped = raw.startsWith("") ? raw.slice(1) : raw;
+        const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+        if (!m)
+            continue;
+        let fm;
+        try {
+            fm = SkillFrontmatter.safeParse(parseYaml(m[1]));
+        }
+        catch {
+            continue;
+        }
+        if (!fm.success)
+            continue;
+        out.push({
+            name: fm.data.name,
+            topic: fm.data.topic ?? [],
+            tech: fm.data.tech ?? [],
+            related: fm.data.related ?? [],
+        });
+    }
+    return out;
+}
+/** Generic kebab tokens that carry no disambiguating signal — ignored in name overlap. */
+const NAME_STOPWORDS = new Set([
+    "workflow", "skill", "review", "guide", "reference", "setup", "and", "the", "a",
+]);
+function nameTokens(name) {
+    return new Set(name
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 1 && !NAME_STOPWORDS.has(t)));
+}
+/** Controlled-vocab terms (TechSeed/TopicSeed) that appear as whole tokens in free text. */
+function vocabTermsInText(text) {
+    const tokens = new Set(text.toLowerCase().split(/[^a-z0-9_-]+/).filter(Boolean));
+    const found = new Set();
+    for (const t of [...TechSeed.options, ...TopicSeed.options]) {
+        if (tokens.has(t))
+            found.add(t);
+    }
+    return found;
+}
+/**
+ * Overlap of an additive (new-skill) proposal against existing domain skills (ADR-DEV-125, Plan A).
+ * Pure + deterministic — callers inject the skill list (readDomainSkillMeta in prod, fixtures in tests).
+ *
+ * A skill is flagged when ANY of:
+ *   - exact name match, OR
+ *   - shares a name token AND a vocab term with the skill's topic/tech, OR
+ *   - near-duplicate name (one name contains the other), OR
+ *   - the skill's related[] already lists the proposed name.
+ */
+export function findOverlaps(args) {
+    const pTokens = nameTokens(args.proposalName);
+    const pVocab = vocabTermsInText(args.text);
+    const pNameLc = args.proposalName.toLowerCase();
+    const overlaps = [];
+    for (const s of args.skills) {
+        const sNameLc = s.name.toLowerCase();
+        if (sNameLc === pNameLc) {
+            overlaps.push({ skill: s.name, reasons: ["exact name match"] });
+            continue;
+        }
+        const reasons = [];
+        const sTokens = nameTokens(s.name);
+        const sharedName = [...pTokens].filter((t) => sTokens.has(t));
+        const sMeta = new Set([...s.topic, ...s.tech]);
+        const sharedVocab = [...pVocab].filter((v) => sMeta.has(v));
+        if (sharedName.length > 0 && sharedVocab.length > 0) {
+            reasons.push(`shares name token(s) [${sharedName.join(", ")}] and topic/tech [${sharedVocab.join(", ")}]`);
+        }
+        if (pNameLc.includes(sNameLc) || sNameLc.includes(pNameLc)) {
+            reasons.push("near-duplicate name (one contains the other)");
+        }
+        if (s.related.includes(args.proposalName)) {
+            reasons.push("already referenced in this skill's related[]");
+        }
+        if (reasons.length > 0)
+            overlaps.push({ skill: s.name, reasons });
+    }
+    return overlaps;
+}

package/dist/mcp/proposal_store.d.ts

@@ -0,0 +1,18 @@
+import { ProposalRecord, ProposalReviewEvent } from "../shared/index.js";
+type ProposalRecordT = ReturnType<typeof ProposalRecord.parse>;
+type ProposalReviewEventT = ReturnType<typeof ProposalReviewEvent.parse>;
+/** Append one proposal as a JSON line (creates the audit dir if needed). */
+export declare function appendProposal(record: ProposalRecordT): Promise<void>;
+/** Append a status-transition event (event-sourcing; never rewrites the original record). */
+export declare function appendReviewEvent(event: ProposalReviewEventT): Promise<void>;
+/**
+ * All proposals with their EFFECTIVE status (latest review event folded in). The on-disk
+ * record is never mutated — folding happens on read. list_proposals consumes this.
+ */
+export declare function readProposals(): Promise<ProposalRecordT[]>;
+/**
+ * Next sequential id, derived from the count of base proposal RECORDS (not raw lines, so
+ * review events never inflate the counter): prop-0001, prop-0002, …
+ */
+export declare function nextProposalId(): Promise<string>;
+export {};

package/dist/mcp/proposal_store.js

@@ -0,0 +1,74 @@
+import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { ProposalRecord, ProposalReviewEvent } from "../shared/index.js";
+import { resolveProposalsPath } from "./paths.js";
+/** Append one proposal as a JSON line (creates the audit dir if needed). */
+export async function appendProposal(record) {
+    const path = resolveProposalsPath();
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(record) + "\n", "utf8");
+}
+/** Append a status-transition event (event-sourcing; never rewrites the original record). */
+export async function appendReviewEvent(event) {
+    const path = resolveProposalsPath();
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(event) + "\n", "utf8");
+}
+/**
+ * Read+classify every line as a base proposal record or a review event. A line that parses
+ * as neither is skipped (tolerant, like the run ledger). Records are tried first; a review
+ * event lacks the record's required fields so it can never be misread as a record.
+ */
+async function readEntries() {
+    const raw = await readFile(resolveProposalsPath(), "utf8").catch(() => "");
+    const records = [];
+    const events = [];
+    if (!raw)
+        return { records, events };
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const rec = ProposalRecord.safeParse(obj);
+        if (rec.success) {
+            records.push(rec.data);
+            continue;
+        }
+        const ev = ProposalReviewEvent.safeParse(obj);
+        if (ev.success)
+            events.push(ev.data);
+        // else: skip
+    }
+    return { records, events };
+}
+/**
+ * All proposals with their EFFECTIVE status (latest review event folded in). The on-disk
+ * record is never mutated — folding happens on read. list_proposals consumes this.
+ */
+export async function readProposals() {
+    const { records, events } = await readEntries();
+    const latest = new Map();
+    for (const e of events) {
+        const prev = latest.get(e.id);
+        if (!prev || e.reviewed_at >= prev.reviewed_at)
+            latest.set(e.id, e);
+    }
+    return records.map((r) => {
+        const e = latest.get(r.id);
+        return e ? { ...r, status: e.status } : r;
+    });
+}
+/**
+ * Next sequential id, derived from the count of base proposal RECORDS (not raw lines, so
+ * review events never inflate the counter): prop-0001, prop-0002, …
+ */
+export async function nextProposalId() {
+    const { records } = await readEntries();
+    return `prop-${String(records.length + 1).padStart(4, "0")}`;
+}

package/dist/mcp/scorecard.d.ts

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import type { TaskState } from "./task_state.js";
+/**
+ * Run scorecard — a compact, per-pipeline-run summary derived ENTIRELY from
+ * telemetry the MCP state machine already persists (task state + jsonl side
+ * logs). One scorecard is appended to the run ledger when a run completes
+ * (RG signed). The Auditor's aggregation tool crunches >=3 of these.
+ *
+ * Deliberately records raw signals, not judgments — interpretation belongs to
+ * the aggregator (numbers) and, later, the Auditor agent (findings).
+ *
+ * Attribution note: scorecards record GATES, not agents. The gate→agent mapping
+ * lives in pipeline.yaml (produced_by) and is applied at aggregation time, so
+ * the ledger never duplicates that mapping (single source).
+ */
+export declare const SCORECARD_SCHEMA_VERSION: 1;
+export declare const GateScore: z.ZodObject<{
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    signoff_count: z.ZodNumber;
+    last_signer: z.ZodNullable<z.ZodEnum<{
+        den: "den";
+        mcp: "mcp";
+        system: "system";
+    }>>;
+    classification: z.ZodNullable<z.ZodEnum<{
+        auto_resolve: "auto_resolve";
+        fork: "fork";
+        exception: "exception";
+    }>>;
+    exceptions_count: z.ZodNumber;
+}, z.core.$strip>;
+export type GateScore = z.infer<typeof GateScore>;
+export declare const SkillInvocationScore: z.ZodObject<{
+    skill: z.ZodString;
+    gate: z.ZodNullable<z.ZodString>;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export type SkillInvocationScore = z.infer<typeof SkillInvocationScore>;
+export declare const RunScorecard: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    task_id: z.ZodString;
+    mode: z.ZodEnum<{
+        full: "full";
+        bugfix: "bugfix";
+        hotfix: "hotfix";
+    }>;
+    completed: z.ZodBoolean;
+    created_at: z.ZodString;
+    completed_at: z.ZodNullable<z.ZodString>;
+    gates: z.ZodArray<z.ZodObject<{
+        gate: z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>;
+        signoff_count: z.ZodNumber;
+        last_signer: z.ZodNullable<z.ZodEnum<{
+            den: "den";
+            mcp: "mcp";
+            system: "system";
+        }>>;
+        classification: z.ZodNullable<z.ZodEnum<{
+            auto_resolve: "auto_resolve";
+            fork: "fork";
+            exception: "exception";
+        }>>;
+        exceptions_count: z.ZodNumber;
+    }, z.core.$strip>>;
+    dev_rollback_count: z.ZodNumber;
+    circuit_breaker_tripped: z.ZodBoolean;
+    exceptions_count: z.ZodNumber;
+    decisions_count: z.ZodNumber;
+    skill_invocations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        skill: z.ZodString;
+        gate: z.ZodNullable<z.ZodString>;
+        count: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RunScorecard = z.infer<typeof RunScorecard>;
+/** Side telemetry the builder cannot read from task state alone. */
+export type ScorecardExtras = {
+    /** Exceptions grouped by gate name (from exceptions.jsonl). */
+    exceptions_by_gate: Partial<Record<string, number>>;
+    /** Total ADR decisions recorded for the task (from decisions.jsonl). */
+    decisions_count: number;
+    /** Raw skill-invocation events for the task (from skill_invocations.jsonl). */
+    skill_invocations?: Array<{
+        skill: string;
+        gate: string | null;
+    }>;
+};
+/**
+ * Build a run scorecard from a task's persisted state plus side-log counts.
+ * Pure + synchronous: deterministic and unit-testable on synthetic state.
+ */
+export declare function buildScorecard(state: TaskState, extras: ScorecardExtras): RunScorecard;

package/dist/mcp/scorecard.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { ClassificationOutcome, GateName, PipelineMode, Signer, } from "../shared/index.js";
+/**
+ * Run scorecard — a compact, per-pipeline-run summary derived ENTIRELY from
+ * telemetry the MCP state machine already persists (task state + jsonl side
+ * logs). One scorecard is appended to the run ledger when a run completes
+ * (RG signed). The Auditor's aggregation tool crunches >=3 of these.
+ *
+ * Deliberately records raw signals, not judgments — interpretation belongs to
+ * the aggregator (numbers) and, later, the Auditor agent (findings).
+ *
+ * Attribution note: scorecards record GATES, not agents. The gate→agent mapping
+ * lives in pipeline.yaml (produced_by) and is applied at aggregation time, so
+ * the ledger never duplicates that mapping (single source).
+ */
+export const SCORECARD_SCHEMA_VERSION = 1;
+export const GateScore = z.object({
+    gate: GateName,
+    /** How many sign-offs this gate received. >1 means the gate was reworked. */
+    signoff_count: z.number().int().nonnegative(),
+    last_signer: Signer.nullable(),
+    /** Latest classification outcome recorded for the gate, if any. */
+    classification: ClassificationOutcome.nullable(),
+    /** Exceptions filed AT this gate (from exceptions.jsonl, grouped by gate). */
+    exceptions_count: z.number().int().nonnegative(),
+});
+export const SkillInvocationScore = z.object({
+    skill: z.string(),
+    /** Gate the skill was pulled at, or null. String (not GateName) — tolerant of
+     *  hand-edited telemetry; this is a surfacing layer, not gate-machine state. */
+    gate: z.string().nullable(),
+    count: z.number().int().positive(),
+});
+export const RunScorecard = z.object({
+    schema_version: z.literal(SCORECARD_SCHEMA_VERSION),
+    task_id: z.string().min(1),
+    mode: PipelineMode,
+    /** True when an RG sign-off exists (the state machine does not set completed_at). */
+    completed: z.boolean(),
+    created_at: z.string(),
+    /** Timestamp of the RG sign-off, or null if not completed. */
+    completed_at: z.string().nullable(),
+    gates: z.array(GateScore),
+    dev_rollback_count: z.number().int().nonnegative(),
+    circuit_breaker_tripped: z.boolean(),
+    exceptions_count: z.number().int().nonnegative(),
+    decisions_count: z.number().int().nonnegative(),
+    /** Skills pulled via get_skill during the run, grouped by skill+gate. */
+    skill_invocations: z.array(SkillInvocationScore).default([]),
+});
+/**
+ * Build a run scorecard from a task's persisted state plus side-log counts.
+ * Pure + synchronous: deterministic and unit-testable on synthetic state.
+ */
+export function buildScorecard(state, extras) {
+    // Group sign-offs by gate: count + last signer (last in chronological array).
+    const signoffCount = new Map();
+    const lastSigner = new Map();
+    for (const s of state.signoffs) {
+        signoffCount.set(s.gate, (signoffCount.get(s.gate) ?? 0) + 1);
+        lastSigner.set(s.gate, s.signer);
+    }
+    // Latest classification per gate (last wins).
+    const lastClass = new Map();
+    for (const c of state.classifications)
+        lastClass.set(c.gate, c.outcome);
+    // Union of gates that have any signal (signoff or classification).
+    const gateNames = new Set([...signoffCount.keys(), ...lastClass.keys()]);
+    const gates = [...gateNames].sort().map((gate) => ({
+        gate: gate,
+        signoff_count: signoffCount.get(gate) ?? 0,
+        last_signer: lastSigner.get(gate) ?? null,
+        classification: lastClass.get(gate) ?? null,
+        exceptions_count: extras.exceptions_by_gate[gate] ?? 0,
+    }));
+    const rgSignoffs = state.signoffs.filter((s) => s.gate === "RG");
+    const completed = rgSignoffs.length > 0;
+    const completed_at = completed ? rgSignoffs[rgSignoffs.length - 1].timestamp : null;
+    const exceptions_count = Object.values(extras.exceptions_by_gate).reduce((a, b) => a + (b ?? 0), 0);
+    // Group skill invocations by skill + gate into counts.
+    const skillAgg = new Map();
+    for (const ev of extras.skill_invocations ?? []) {
+        const key = `${ev.skill}|${ev.gate ?? ""}`;
+        const e = skillAgg.get(key) ?? { skill: ev.skill, gate: ev.gate, count: 0 };
+        e.count++;
+        skillAgg.set(key, e);
+    }
+    const skill_invocations = [...skillAgg.values()].sort((a, b) => (a.skill + (a.gate ?? "")).localeCompare(b.skill + (b.gate ?? "")));
+    return RunScorecard.parse({
+        schema_version: SCORECARD_SCHEMA_VERSION,
+        task_id: state.task_id,
+        mode: state.mode,
+        completed,
+        created_at: state.created_at,
+        completed_at,
+        gates,
+        dev_rollback_count: state.dev_rollback_count,
+        circuit_breaker_tripped: state.audit_required_at !== undefined,
+        exceptions_count,
+        decisions_count: extras.decisions_count,
+        skill_invocations,
+    });
+}

package/dist/mcp/skill_invocations.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Skill-invocation telemetry. A `get_skill` fetch associated with a run is the
+ * invocation signal — the agent decided the skill was relevant and pulled it.
+ * Append-only JSONL; one event per line. Read back per task by the scorecard
+ * builder. Best-effort by contract: a logging failure must never break a read.
+ */
+export type SkillInvocation = {
+    task_id: string;
+    gate: string | null;
+    skill: string;
+    timestamp: string;
+};
+export declare function recordSkillInvocation(ev: SkillInvocation): Promise<void>;
+/** All invocation events for one task. Malformed / partial lines are skipped. */
+export declare function readSkillInvocations(taskId: string): Promise<SkillInvocation[]>;

package/dist/mcp/skill_invocations.js

@@ -0,0 +1,28 @@
+import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { resolveSkillInvocationsPath } from "./paths.js";
+export async function recordSkillInvocation(ev) {
+    const path = resolveSkillInvocationsPath();
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(ev) + "\n", "utf8");
+}
+/** All invocation events for one task. Malformed / partial lines are skipped. */
+export async function readSkillInvocations(taskId) {
+    const raw = await readFile(resolveSkillInvocationsPath(), "utf8").catch(() => "");
+    if (!raw)
+        return [];
+    const out = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            if (o.task_id === taskId)
+                out.push(o);
+        }
+        catch {
+            continue;
+        }
+    }
+    return out;
+}

package/dist/mcp/task_state.d.ts

@@ -18,10 +18,25 @@ export declare const GateSignoff: z.ZodObject<{
         OPS: "OPS";
         TEST: "TEST";
         RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
     }>;
     signer: z.ZodEnum<{
-        mcp: "mcp";
         den: "den";
+        mcp: "mcp";
         system: "system";
     }>;
     timestamp: z.ZodString;
@@ -38,6 +53,21 @@ export declare const GateClassification: z.ZodObject<{
         OPS: "OPS";
         TEST: "TEST";
         RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
     }>;
     outcome: z.ZodEnum<{
         auto_resolve: "auto_resolve";
@@ -64,6 +94,21 @@ export declare const TaskState: z.ZodObject<{
         OPS: "OPS";
         TEST: "TEST";
         RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
     }>;
     signoffs: z.ZodDefault<z.ZodArray<z.ZodObject<{
         gate: z.ZodEnum<{
@@ -75,10 +120,25 @@ export declare const TaskState: z.ZodObject<{
             OPS: "OPS";
             TEST: "TEST";
             RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
         }>;
         signer: z.ZodEnum<{
-            mcp: "mcp";
             den: "den";
+            mcp: "mcp";
             system: "system";
         }>;
         timestamp: z.ZodString;
@@ -94,6 +154,21 @@ export declare const TaskState: z.ZodObject<{
             OPS: "OPS";
             TEST: "TEST";
             RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
         }>;
         outcome: z.ZodEnum<{
             auto_resolve: "auto_resolve";

package/dist/mcp/tools/_subprocess.d.ts

@@ -0,0 +1,16 @@
+export interface SubprocessResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    spawnError?: Error;
+}
+export interface SpawnOptions {
+    cwd: string;
+    env?: Record<string, string>;
+    /** When set, the string is written to the process's stdin then closed. */
+    stdin?: string;
+}
+export declare function npmCommand(): string;
+export declare function spawnWithOutput(command: string, args: string[], opts: SpawnOptions): Promise<SubprocessResult>;
+export declare function tail(text: string, maxBytes: number): string;