@birdie_moblie/open_spec 2.1.7

package/dist/core/todo.js

@@ -0,0 +1,114 @@
+import { readFileSync, statSync } from 'node:fs';
+import { z } from 'zod';
+import { exists, readText } from '../shared/fs.js';
+import { AppError } from '../shared/errors.js';
+import { isInsideDir, isOpsxInternal, normalizeRel, resolveInside } from '../shared/paths.js';
+import { requireChange } from './change.js';
+import { eventsPath } from './state.js';
+export const PendingWorkSchema = z.object({
+    changeName: z.string(),
+    items: z.array(z.object({
+        category: z.string(),
+        source: z.enum(['code', 'worker']),
+        file: z.string(),
+        line: z.number().int().positive(),
+        text: z.string(),
+        marker: z.enum(['TODO', 'FIXME']).optional(),
+        workerId: z.string().optional(),
+        stepId: z.string().optional(),
+    }).strict()),
+    skippedFiles: z.array(z.object({ file: z.string(), reason: z.string() }).strict()),
+}).strict();
+export function reviewScopedFiles(config, files) {
+    const scope = config.verify?.reviewScope;
+    return [...new Set(files.map(normalizeRel))].filter((file) => {
+        if (isOpsxInternal(file))
+            return false;
+        if (scope?.includeDirs?.length && !scope.includeDirs.some((dir) => isInsideDir(file, dir)))
+            return false;
+        return !scope?.excludeDirs?.some((dir) => isInsideDir(file, dir));
+    }).sort();
+}
+/** 只读当前 changed-set；历史 Worker 声明单独展示，不推断其已解决。 */
+export function collectPendingWork(projectRoot, changeName, config) {
+    const state = requireChange(projectRoot, changeName);
+    const result = { changeName, items: [], skippedFiles: [] };
+    for (const file of reviewScopedFiles(config, state.engineChangedFiles)) {
+        const absolute = resolveInside(projectRoot, file, 'todo_path_outside_project');
+        if (!exists(absolute) || !statSync(absolute).isFile()) {
+            result.skippedFiles.push({ file, reason: '文件已删除或不是普通文件' });
+            continue;
+        }
+        const data = readFileSync(absolute);
+        if (data.includes(0)) {
+            result.skippedFiles.push({ file, reason: '二进制文件' });
+            continue;
+        }
+        for (const [index, line] of data.toString('utf8').split(/\r?\n/).entries()) {
+            for (const match of markers(line)) {
+                result.items.push({ source: 'code', file, line: index + 1, ...match });
+            }
+        }
+    }
+    const events = eventsPath(projectRoot, changeName);
+    if (exists(events)) {
+        for (const [index, line] of readText(events).split(/\r?\n/).entries()) {
+            if (!line.trim())
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                throw new AppError('invalid_events', `events.jsonl 第 ${index + 1} 行无法解析`);
+            }
+            if (event.type !== 'worker.accepted' || typeof event.payload?.notes !== 'string')
+                continue;
+            const { notes, workerId, stepId } = event.payload;
+            let pendingSection = false;
+            for (const noteLine of notes.split(/\r?\n/)) {
+                const heading = /^\s*#{1,6}\s+/.test(noteLine)
+                    || /^\s*[^:：]+[:：]\s*$/.test(noteLine);
+                const pending = /未能满足|占位/.test(noteLine) && !/(无|没有|无需|不需要|禁止|不得)\s*(占位|未能满足)|(?:未能满足|占位)\s*[:：]\s*无/.test(noteLine);
+                if (heading)
+                    pendingSection = pending;
+                const found = markers(noteLine);
+                if ((!found.length && !(pending || pendingSection)) || !noteLine.trim())
+                    continue;
+                // 章节标题用于确定范围，本身不是一条待办。
+                if (heading && !found.length)
+                    continue;
+                const base = { source: 'worker', file: `openspec/changes/${changeName}/.opsx/events.jsonl`, line: index + 1,
+                    workerId: typeof workerId === 'string' ? workerId : undefined, stepId: typeof stepId === 'string' ? stepId : undefined };
+                if (found.length)
+                    result.items.push(...found.map((item) => ({ ...base, ...item })));
+                else
+                    result.items.push({ ...base, category: 'worker', text: noteLine.trim() });
+            }
+        }
+    }
+    return result;
+}
+function markers(line) {
+    const matches = [...line.matchAll(/\b(TODO|FIXME)\b(?:\(([^)\r\n]+)\))?\s*[:：]?\s*/g)];
+    return matches.map((match, i) => ({
+        marker: match[1],
+        category: match[2]?.trim() || 'general',
+        text: line.slice(match.index + match[0].length, matches[i + 1]?.index).replace(/\s*\*\/\s*$/, '').trim(),
+    }));
+}
+export function renderPendingWork(pending) {
+    const lines = [`# Pending work — ${pending.changeName}`, '', '非阻塞待办；Worker 项是验收时的历史声明，需人工核实是否已解决。'];
+    for (const category of [...new Set(pending.items.map((item) => item.category))].sort()) {
+        lines.push('', `## ${category}`);
+        for (const item of pending.items.filter((entry) => entry.category === category)) {
+            lines.push(`- ${item.file}:${item.line}: ${item.text}${item.source === 'worker' ? ` [worker ${item.stepId ?? item.workerId ?? ''}]` : ''}`);
+        }
+    }
+    if (!pending.items.length)
+        lines.push('', '无待办。');
+    if (pending.skippedFiles.length)
+        lines.push('', '## 未扫描文件', ...pending.skippedFiles.map((item) => `- ${item.file}: ${item.reason}`));
+    return `${lines.join('\n')}\n`;
+}
+//# sourceMappingURL=todo.js.map

package/dist/core/types.d.ts

@@ -0,0 +1,297 @@
+import { z } from 'zod';
+import { type PluginIdentity } from '../marketplace/adapters.js';
+import { type PluginBinding } from '../hooks/plugin-runtime.js';
+export declare const STATE_VERSION = 1;
+export declare const PACKET_VERSION = 1;
+export declare const NODES: {
+    readonly COLLECT: "collect";
+    readonly PARSE: "parse";
+    readonly TECH: "tech";
+    readonly PLAN: "plan";
+    readonly GATE_A: "gate_a";
+    readonly CODE: "code";
+    readonly GATE_B: "gate_b";
+    readonly VERIFY: "verify";
+    readonly GATE_C: "gate_c";
+    readonly COMPLETED: "completed";
+};
+export type Node = (typeof NODES)[keyof typeof NODES];
+export declare const GATE_IDS: readonly ["gate-A", "gate-B", "gate-C"];
+export type GateId = (typeof GATE_IDS)[number];
+export type GateStatus = 'pending' | 'approved' | 'rejected';
+export type WorkerResultStatus = 'completed' | 'failed' | 'blocked';
+export type TaskStatus = 'pending' | 'completed';
+export type SourceCapability = 'requirements' | 'interfaces' | 'design';
+export interface GateState {
+    status: GateStatus;
+    comment?: string;
+    reason?: string;
+    updatedAt?: string;
+}
+export interface TaskState {
+    id: string;
+    title: string;
+    category: string;
+    type?: 'code' | 'interface-codegen';
+    dependsOn: string[];
+    status: TaskStatus;
+    completedAt?: string;
+}
+/** 详情以 task-plan.json 为唯一来源，不写入调度状态。 */
+export interface TaskPlanTask extends TaskState {
+    refScope?: string[];
+    notes?: string;
+    capability?: string;
+    operation?: string;
+    provider?: string;
+    sourceRefs?: string[];
+    designRefs?: string[];
+}
+export interface LastIssue {
+    type: 'worker_failed' | 'worker_blocked' | 'gate_rejected';
+    stepId?: string;
+    gateId?: GateId;
+    fixable?: boolean;
+    questions?: string[];
+    reason?: string;
+    updatedAt: string;
+}
+export interface ActiveWorker {
+    workerId: string;
+    stepId: string;
+    packet: string;
+    expectedResult: string;
+    createdAt: string;
+}
+export interface SourceUpdate {
+    fromRevision: number;
+    startedAt: string;
+    previousNode: Node;
+    hadCompletedTasks: boolean;
+    backupPath: string;
+    completedTaskIds: string[];
+    changedSourceIds: string[];
+}
+export interface VerifyRepair {
+    sourceVerifyRunId: string;
+    requestedAt: string;
+    reason: string;
+}
+export interface ChangeState {
+    version: number;
+    changeName: string;
+    node: Node;
+    sourceRevision: number;
+    collectedRevision: number;
+    gates: Record<GateId, GateState>;
+    tasks: TaskState[];
+    engineChangedFiles: string[];
+    /** Original baseline and file ownership survive cancellation and source revisions. */
+    codeChanges?: {
+        baseline: string;
+        filesByStep: Record<string, string[]>;
+        pendingSteps?: string[];
+    };
+    activeWorker: ActiveWorker | null;
+    techSkipped: boolean;
+    lastIssue: LastIssue | null;
+    sourceUpdate: SourceUpdate | null;
+    verifyRunId: string | null;
+    repair: VerifyRepair | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SourceItem {
+    id: string;
+    capability: SourceCapability;
+    kind: 'url' | 'text' | 'file';
+    locator: string;
+    artifact?: string;
+    artifactSha256?: string;
+    adapter?: {
+        use: string;
+        identity: PluginIdentity;
+    };
+    /** CLI-owned checkpoint, present only during an unfinished collect. */
+    collection?: {
+        fingerprint: string;
+        artifactSha256: string;
+    };
+}
+export interface SourcesLedger {
+    revision: number;
+    notes: string;
+    items: SourceItem[];
+}
+export interface WorkerPacket {
+    version: number;
+    workerId: string;
+    stepId: string;
+    changeName: string;
+    node: Node;
+    task?: Pick<TaskPlanTask, 'id' | 'title' | 'category' | 'type' | 'refScope' | 'dependsOn' | 'notes' | 'sourceRefs' | 'capability' | 'operation' | 'provider' | 'designRefs'>;
+    initContext?: TaskInitContext;
+    executionEvidence?: true;
+    executionEvidenceVersion?: 2;
+    planNotes?: string;
+    allowedCategories?: string[];
+    skipTechAllowed?: boolean;
+    refs: {
+        [key: string]: string | DesignSourceRef[] | undefined;
+        design?: DesignSourceRef[];
+    };
+    expectedResult: string;
+    /** Worker blocked 后用户的答复；再次 create 复用 packet 时 Worker 必须按此完成产物 */
+    decisions?: WorkerDecision[];
+    /** verify Worker：本 run 需要登记证据的 verify 阶段 hook（command 由 `verify commands` 执行） */
+    verifyHooks?: ExecuteHookDescriptor[];
+}
+export interface DesignSourceRef {
+    sourceId: string;
+    kind: SourceItem['kind'];
+    locator?: string;
+    artifact?: string;
+}
+export interface WorkerDecision {
+    questions: string[];
+    answers: string[];
+    answeredAt: string;
+}
+export interface WorkerResult {
+    workerId: string;
+    stepId: string;
+    status: WorkerResultStatus;
+    changedFiles?: string[];
+    skipTech?: boolean;
+    notes?: string;
+    questions?: string[];
+    artifacts?: string[];
+    executeHookResults?: ExecuteHookResult[];
+}
+export interface InitRule {
+    source: 'category' | 'task';
+    text: string;
+}
+export type ExecuteHookDescriptor = {
+    purpose?: string;
+    plugin?: PluginBinding;
+} & ({
+    id: string;
+    type: 'notes';
+    required: boolean;
+    notes: string;
+}
+/** path：在项目锁定的 marketplace 插件里找到的 SKILL.md 绝对路径；宿主未注册该 skill 时 Worker 可直接读取 */
+ | {
+    id: string;
+    type: 'skill';
+    required: boolean;
+    name: string;
+    path?: string;
+} | {
+    id: string;
+    type: 'file';
+    required: boolean;
+    path: string;
+} | {
+    id: string;
+    type: 'check';
+    required: boolean;
+    category: string;
+    description: string;
+} | {
+    id: string;
+    type: 'command';
+    required: boolean;
+    command: string;
+});
+/** parse/plan/code Worker 共用的初始化上下文；只有 code Worker 带 category。 */
+export interface TaskInitContext {
+    category?: string;
+    rules: InitRule[];
+    hooks: ExecuteHookDescriptor[];
+}
+export interface ExecuteHookResult {
+    id: string;
+    status: 'passed' | 'failed' | 'skipped';
+    notes?: string;
+}
+export type NextAction = {
+    action: 'add_sources';
+    changeName: string;
+} | {
+    action: 'collect_sources';
+    changeName: string;
+} | {
+    action: 'create_worker';
+    changeName: string;
+    stepId: string;
+} | {
+    action: 'retry_worker';
+    changeName: string;
+    stepId: string;
+} | {
+    action: 'await_gate';
+    changeName: string;
+    gateId: GateId;
+} | {
+    action: 'need_user_input';
+    changeName: string;
+    questions?: string[];
+} | {
+    action: 'fix_verify';
+    changeName: string;
+} | {
+    action: 'completed';
+    changeName: string;
+} | {
+    action: 'archive';
+    changeName: string;
+};
+export declare const WORKFLOWS: readonly ["opsx-propose", "opsx-explore", "opsx-apply", "opsx-verify", "opsx-fix-verify", "opsx-resume", "opsx-source-update", "opsx-archive", "opsx-gate-decision"];
+export type WorkflowName = (typeof WORKFLOWS)[number];
+/** 接受旧 state 的详情字段；读取和保存均投影为精简调度状态。 */
+export declare const TaskStateSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        "interface-codegen": "interface-codegen";
+    }>>;
+    refScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependsOn: z.ZodArray<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+    }>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    changedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    capability: z.ZodOptional<z.ZodString>;
+    operation: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    sourceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    designRefs: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+}, z.core.$strict>, z.ZodTransform<TaskState, {
+    id: string;
+    title: string;
+    category: string;
+    dependsOn: string[];
+    status: "completed" | "pending";
+    type?: "code" | "interface-codegen" | undefined;
+    refScope?: string[] | undefined;
+    notes?: string | undefined;
+    completedAt?: string | undefined;
+    changedFiles?: string[] | undefined;
+    capability?: string | undefined;
+    operation?: string | undefined;
+    provider?: string | undefined;
+    sourceRefs?: string[] | undefined;
+    designRefs?: string[] | undefined;
+}>>;
+export declare const ChangeStateSchema: z.ZodType<ChangeState>;
+export declare const SourcesLedgerSchema: z.ZodType<SourcesLedger>;
+export declare const WorkerPacketSchema: z.ZodType<WorkerPacket>;
+export declare const WorkerResultSchema: z.ZodType<WorkerResult>;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import { PluginIdentitySchema } from '../marketplace/adapters.js';
+import { PluginBindingSchema } from '../hooks/plugin-runtime.js';
+export const STATE_VERSION = 1;
+export const PACKET_VERSION = 1;
+export const NODES = {
+    COLLECT: 'collect',
+    PARSE: 'parse',
+    TECH: 'tech',
+    PLAN: 'plan',
+    GATE_A: 'gate_a',
+    CODE: 'code',
+    GATE_B: 'gate_b',
+    VERIFY: 'verify',
+    GATE_C: 'gate_c',
+    COMPLETED: 'completed',
+};
+export const GATE_IDS = ['gate-A', 'gate-B', 'gate-C'];
+export const WORKFLOWS = [
+    'opsx-propose',
+    'opsx-explore',
+    'opsx-apply',
+    'opsx-verify',
+    'opsx-fix-verify',
+    'opsx-resume',
+    'opsx-source-update',
+    'opsx-archive',
+    'opsx-gate-decision',
+];
+const PathTokenSchema = z.string().min(1).refine((value) => value !== '.' && value !== '..' && !/[\\/\0]/.test(value), '标识不能包含路径语义');
+const RelativePathSchema = z.string().min(1).refine((value) => !value.startsWith('/')
+    && !value.startsWith('\\')
+    && !/^[A-Za-z]:[\\/]/.test(value)
+    && !value.includes('\0')
+    && !value.split(/[\\/]/).includes('..'), '必须是未越界的相对路径');
+const ChangeNameSchema = z.string().regex(/^[a-z0-9][a-z0-9-]{0,79}$/);
+const GateStateSchema = z.object({
+    status: z.enum(['pending', 'approved', 'rejected']),
+    comment: z.string().optional(),
+    reason: z.string().optional(),
+    updatedAt: z.string().optional(),
+}).strict();
+const TaskPlanTaskSchema = z.object({
+    id: PathTokenSchema,
+    title: z.string().min(1),
+    category: z.string().min(1),
+    type: z.enum(['code', 'interface-codegen']).optional(),
+    refScope: z.array(RelativePathSchema).optional(),
+    dependsOn: z.array(PathTokenSchema),
+    notes: z.string().optional(),
+    status: z.enum(['pending', 'completed']),
+    completedAt: z.string().optional(),
+    changedFiles: z.array(RelativePathSchema).optional(),
+    capability: z.string().optional(),
+    operation: z.string().optional(),
+    provider: z.string().optional(),
+    sourceRefs: z.array(PathTokenSchema).optional(),
+    designRefs: z.array(z.string().trim().min(1)).transform((refs) => [...new Set(refs)]).optional(),
+}).strict();
+/** 接受旧 state 的详情字段；读取和保存均投影为精简调度状态。 */
+export const TaskStateSchema = TaskPlanTaskSchema.transform(({ id, title, category, type, dependsOn, status, completedAt }) => ({ id, title, category, type, dependsOn, status, completedAt }));
+const LastIssueSchema = z.object({
+    type: z.enum(['worker_failed', 'worker_blocked', 'gate_rejected']),
+    stepId: PathTokenSchema.optional(),
+    gateId: z.enum(GATE_IDS).optional(),
+    fixable: z.boolean().optional(),
+    questions: z.array(z.string()).optional(),
+    reason: z.string().optional(),
+    updatedAt: z.string(),
+}).strict();
+const ActiveWorkerSchema = z.object({
+    workerId: PathTokenSchema,
+    stepId: PathTokenSchema,
+    packet: RelativePathSchema,
+    expectedResult: RelativePathSchema,
+    createdAt: z.string(),
+}).strict();
+const SourceUpdateSchema = z.object({
+    fromRevision: z.number().int().nonnegative(),
+    startedAt: z.string(),
+    previousNode: z.enum(Object.values(NODES)),
+    hadCompletedTasks: z.boolean(),
+    backupPath: z.literal('.opsx/source-update-backup'),
+    completedTaskIds: z.array(PathTokenSchema),
+    changedSourceIds: z.array(PathTokenSchema),
+}).strict();
+const VerifyRepairSchema = z.object({
+    sourceVerifyRunId: PathTokenSchema,
+    requestedAt: z.string(),
+    reason: z.string(),
+}).strict();
+export const ChangeStateSchema = z.object({
+    version: z.literal(STATE_VERSION),
+    changeName: ChangeNameSchema,
+    node: z.enum(Object.values(NODES)),
+    sourceRevision: z.number().int().nonnegative(),
+    collectedRevision: z.number().int().nonnegative(),
+    gates: z.object({
+        'gate-A': GateStateSchema,
+        'gate-B': GateStateSchema,
+        'gate-C': GateStateSchema,
+    }).strict(),
+    tasks: z.array(TaskStateSchema),
+    engineChangedFiles: z.array(RelativePathSchema),
+    codeChanges: z.object({ baseline: RelativePathSchema, filesByStep: z.record(PathTokenSchema, z.array(RelativePathSchema)), pendingSteps: z.array(PathTokenSchema).optional() }).strict().optional(),
+    activeWorker: ActiveWorkerSchema.nullable(),
+    techSkipped: z.boolean(),
+    lastIssue: LastIssueSchema.nullable(),
+    sourceUpdate: SourceUpdateSchema.nullable(),
+    verifyRunId: PathTokenSchema.nullable(),
+    repair: VerifyRepairSchema.nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+}).strict().superRefine((state, ctx) => {
+    if (state.collectedRevision > state.sourceRevision) {
+        ctx.addIssue({ code: 'custom', path: ['collectedRevision'], message: 'collectedRevision 不能大于 sourceRevision' });
+    }
+    const taskIds = new Set();
+    for (const [index, task] of state.tasks.entries()) {
+        if (taskIds.has(task.id))
+            ctx.addIssue({ code: 'custom', path: ['tasks', index, 'id'], message: `重复 task id: ${task.id}` });
+        taskIds.add(task.id);
+    }
+    if (state.activeWorker) {
+        const workerPrefix = `openspec/changes/${state.changeName}/.opsx/workers/`;
+        if (!state.activeWorker.packet.startsWith(workerPrefix) || !state.activeWorker.expectedResult.startsWith(workerPrefix)) {
+            ctx.addIssue({ code: 'custom', path: ['activeWorker'], message: 'active Worker 路径不属于当前 change' });
+        }
+        if (state.activeWorker.stepId === 'verify' && state.verifyRunId !== state.activeWorker.workerId) {
+            ctx.addIssue({ code: 'custom', path: ['verifyRunId'], message: 'verifyRunId 与 active verify Worker 不一致' });
+        }
+    }
+});
+const SourceItemSchema = z.object({
+    id: PathTokenSchema,
+    capability: z.enum(['requirements', 'interfaces', 'design']),
+    kind: z.enum(['url', 'text', 'file']),
+    locator: z.string().min(1),
+    artifact: RelativePathSchema.optional(),
+    artifactSha256: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    adapter: z.object({ use: z.string(), identity: PluginIdentitySchema }).strict().optional(),
+    collection: z.object({ fingerprint: z.string().regex(/^[a-f0-9]{64}$/), artifactSha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict().optional(),
+}).strict();
+export const SourcesLedgerSchema = z.object({
+    revision: z.number().int().nonnegative(),
+    notes: z.string(),
+    items: z.array(SourceItemSchema),
+}).strict().superRefine((ledger, ctx) => {
+    const ids = new Set();
+    for (const [index, item] of ledger.items.entries()) {
+        if (ids.has(item.id))
+            ctx.addIssue({ code: 'custom', path: ['items', index, 'id'], message: `重复 source id: ${item.id}` });
+        ids.add(item.id);
+    }
+});
+const ExecuteHookDescriptorSchema = z.discriminatedUnion('type', [
+    z.object({ purpose: z.string().optional(), plugin: PluginBindingSchema.optional(), id: PathTokenSchema, type: z.literal('notes'), required: z.boolean(), notes: z.string() }).strict(),
+    z.object({ purpose: z.string().optional(), plugin: PluginBindingSchema.optional(), id: PathTokenSchema, type: z.literal('skill'), required: z.boolean(), name: z.string(), path: z.string().optional() }).strict(),
+    z.object({ purpose: z.string().optional(), plugin: PluginBindingSchema.optional(), id: PathTokenSchema, type: z.literal('file'), required: z.boolean(), path: RelativePathSchema }).strict(),
+    z.object({ purpose: z.string().optional(), plugin: PluginBindingSchema.optional(), id: PathTokenSchema, type: z.literal('check'), required: z.boolean(), category: z.string(), description: z.string() }).strict(),
+    z.object({ purpose: z.string().optional(), plugin: PluginBindingSchema.optional(), id: PathTokenSchema, type: z.literal('command'), required: z.boolean(), command: z.string() }).strict(),
+]);
+const TaskInitContextSchema = z.object({
+    category: z.string().optional(),
+    rules: z.array(z.object({ source: z.enum(['category', 'task']), text: z.string() }).strict()),
+    hooks: z.array(ExecuteHookDescriptorSchema),
+}).strict();
+const PacketTaskSchema = TaskPlanTaskSchema.pick({
+    id: true,
+    title: true,
+    category: true,
+    type: true,
+    refScope: true,
+    dependsOn: true,
+    notes: true,
+    sourceRefs: true,
+    designRefs: true,
+    capability: true,
+    operation: true,
+    provider: true,
+});
+export const WorkerPacketSchema = z.object({
+    version: z.literal(PACKET_VERSION),
+    workerId: PathTokenSchema,
+    stepId: PathTokenSchema,
+    changeName: ChangeNameSchema,
+    node: z.enum(Object.values(NODES)),
+    task: PacketTaskSchema.optional(),
+    initContext: TaskInitContextSchema.optional(),
+    executionEvidence: z.literal(true).optional(),
+    executionEvidenceVersion: z.literal(2).optional(),
+    planNotes: z.string().optional(),
+    allowedCategories: z.array(z.string()).optional(),
+    skipTechAllowed: z.boolean().optional(),
+    refs: z.object({
+        design: z.array(z.object({
+            sourceId: PathTokenSchema,
+            kind: z.enum(['url', 'file', 'text']),
+            locator: z.string().min(1).optional(),
+            artifact: RelativePathSchema.optional(),
+        }).strict()).optional(),
+    }).catchall(RelativePathSchema),
+    expectedResult: RelativePathSchema,
+    decisions: z.array(z.object({
+        questions: z.array(z.string()),
+        answers: z.array(z.string().min(1)).min(1),
+        answeredAt: z.string(),
+    }).strict()).optional(),
+    verifyHooks: z.array(ExecuteHookDescriptorSchema).optional(),
+}).strict();
+const ExecuteHookResultSchema = z.object({
+    id: PathTokenSchema,
+    status: z.enum(['passed', 'failed', 'skipped']),
+    notes: z.string().optional(),
+}).strict();
+export const WorkerResultSchema = z.object({
+    workerId: PathTokenSchema,
+    stepId: PathTokenSchema,
+    status: z.enum(['completed', 'failed', 'blocked']),
+    changedFiles: z.array(RelativePathSchema).optional(),
+    skipTech: z.boolean().optional(),
+    notes: z.string().optional(),
+    questions: z.array(z.string()).optional(),
+    artifacts: z.array(z.string()).optional(),
+    executeHookResults: z.array(ExecuteHookResultSchema).optional(),
+}).strict();
+//# sourceMappingURL=types.js.map