@captain_z/zsk 1.8.6 → 1.8.8

package/dist/commands/work.js

@@ -0,0 +1,1769 @@
+import pc from "picocolors";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import YAML from "yaml";
+import { checkProjectConfig, readProjectConfig } from "../core/config.js";
+import { resolvePath } from "../core/targets.js";
+import { assignmentProviderRef, buildAssignmentProviderCommandPlan, buildProviderCommandPlan, commandDisplayWithMetadata, } from "../core/work-provider-adapters.js";
+import { appendWorkEvents, latestWorkItem, readWorkEvents, resolveWorkLedgerPath } from "../core/work-ledger.js";
+import { getWorkspacePath } from "../core/workspace-layout.js";
+import { isPathInside, resolveProjectPath } from "../core/workspace-conformance.js";
+import { refreshIssueIndexes, updateIssueStatusBlock } from "./issue.js";
+export async function sync(opts = {}) {
+    if (!opts.dryRun) {
+        console.error(pc.red("✗ remote work sync is not enabled yet; rerun with --dry-run"));
+        process.exit(1);
+    }
+    const { target, config, workConfigPath, provider, providerConfig } = await loadWorkContext(opts, "sync");
+    const { ledgerPath } = await resolveWorkLedgerPath(target, config);
+    const events = await readWorkEvents(ledgerPath);
+    const now = new Date().toISOString();
+    const plan = buildSyncPlan({
+        target,
+        provider,
+        providerConfig,
+        workConfigPath,
+        ledgerPath,
+        events,
+        generatedAt: now,
+    });
+    const evidenceDir = resolve(target, getWorkspacePath(config, "evidenceRoot"), "work-sync", runId(now));
+    await mkdir(evidenceDir, { recursive: true });
+    const jsonPath = join(evidenceDir, "sync-plan.json");
+    const mdPath = join(evidenceDir, "sync-plan.md");
+    await writeFile(jsonPath, `${JSON.stringify(plan, null, 2)}\n`, "utf8");
+    await writeFile(mdPath, renderSyncPlan(plan), "utf8");
+    if (opts.json) {
+        console.log(JSON.stringify({ plan, artifacts: { json: jsonPath, markdown: mdPath } }, null, 2));
+        return;
+    }
+    console.log(pc.green("✓ zsk work sync dry-run completed"));
+    console.log(pc.dim(`provider: ${provider}`));
+    console.log(pc.dim(`adapter: ${plan.adapter ?? "unknown"}`));
+    console.log(pc.dim(`work config: ${workConfigPath}`));
+    console.log(pc.dim(`ledger: ${ledgerPath}${events.length === 0 ? " (no events)" : ""}`));
+    console.log(pc.dim(`events: ${plan.eventCount}; actionable: ${plan.actionableCount}; blocked: ${plan.blockedCount}`));
+    console.log(pc.dim(`provider commands: ${plan.providerCommandPlan.commandCount}; command blockers: ${plan.providerCommandPlan.blockedCount}`));
+    console.log(pc.dim("remote side effects: none"));
+    console.log(pc.dim(`sync plan: ${jsonPath}`));
+    console.log(pc.dim(`summary: ${mdPath}`));
+}
+export async function assign(opts = {}) {
+    if (!opts.item) {
+        console.error(pc.red("✗ missing work item id; pass --item <id>"));
+        process.exit(1);
+    }
+    if (!opts.agent && !opts.squad && !opts.role) {
+        console.error(pc.red("✗ assignment needs --agent, --squad, or --role"));
+        process.exit(1);
+    }
+    const { target, config, workConfigPath, provider, providerConfig } = await loadWorkContext(opts, "assign");
+    const { ledgerPath } = await resolveWorkLedgerPath(target, config);
+    const existingEvents = await readWorkEvents(ledgerPath);
+    const previousWorkItem = latestWorkItem(existingEvents, opts.item);
+    const teamConfigPath = resolveInsideProject(target, config.customize?.team ?? ".zsk/team.yaml", "team config");
+    const teamConfig = await readTeamConfig(teamConfigPath);
+    const assignment = resolveAssignment(opts, provider, teamConfig);
+    const now = new Date().toISOString();
+    const evidenceDir = resolve(target, getWorkspacePath(config, "evidenceRoot"), "work-assign", runId(now));
+    const jsonPath = join(evidenceDir, "assignment-plan.json");
+    const mdPath = join(evidenceDir, "assignment-plan.md");
+    const workItem = resolveAssignmentWorkItem(opts, providerConfig, previousWorkItem);
+    const providerConfigured = providerLooksConfigured(providerConfig);
+    const providerCommandPlan = buildAssignmentProviderCommandPlan({
+        provider,
+        providerConfig,
+        providerConfigured,
+        workItem,
+        assignment,
+    });
+    const assignmentEvents = buildAssignmentEvents({
+        target,
+        provider,
+        evidencePath: jsonPath,
+        assignedAt: now,
+        existingEvents,
+        previous: previousWorkItem,
+        workItem,
+        assignment,
+        providerCommandPlan,
+    });
+    const appendedCount = opts.dryRun ? 0 : assignmentEvents.length;
+    const plan = {
+        version: 1,
+        dryRun: Boolean(opts.dryRun),
+        provider,
+        adapter: providerConfig.adapter ?? null,
+        generatedAt: now,
+        target,
+        workConfig: workConfigPath,
+        teamConfig: teamConfigPath,
+        ledger: ledgerPath,
+        providerConfigured,
+        remoteSideEffects: "none",
+        localSideEffects: appendedCount > 0 ? "append-work-ledger" : "none",
+        appendedCount,
+        workItem,
+        assignment,
+        providerCommandPlan,
+        qualityGates: assignmentQualityGates(assignment, teamConfig, providerConfigured, providerCommandPlan),
+    };
+    await mkdir(evidenceDir, { recursive: true });
+    if (!opts.dryRun && assignmentEvents.length > 0) {
+        await appendWorkEvents(ledgerPath, assignmentEvents);
+    }
+    await writeFile(jsonPath, `${JSON.stringify(plan, null, 2)}\n`, "utf8");
+    await writeFile(mdPath, renderAssignmentPlan(plan), "utf8");
+    if (opts.json) {
+        console.log(JSON.stringify({ plan, artifacts: { json: jsonPath, markdown: mdPath } }, null, 2));
+        return;
+    }
+    console.log(pc.green(`✓ zsk work assign ${opts.dryRun ? "dry-run " : ""}completed`));
+    console.log(pc.dim(`provider: ${provider}`));
+    console.log(pc.dim(`work item: ${opts.item}`));
+    console.log(pc.dim(`assignment: ${assignment.mode}:${assignment.agent ?? assignment.squad ?? assignment.role}`));
+    console.log(pc.dim(`role: ${assignment.role}`));
+    console.log(pc.dim(`provider commands: ${plan.providerCommandPlan.commandCount}; command blockers: ${plan.providerCommandPlan.blockedCount}`));
+    console.log(pc.dim("remote side effects: none"));
+    console.log(pc.dim(`local side effects: ${plan.localSideEffects}`));
+    console.log(pc.dim(`ledger: ${ledgerPath}${plan.appendedCount > 0 ? ` (${plan.appendedCount} appended)` : ""}`));
+    console.log(pc.dim(`assignment plan: ${jsonPath}`));
+    console.log(pc.dim(`summary: ${mdPath}`));
+}
+export async function importStatus(opts = {}) {
+    if (!opts.file) {
+        console.error(pc.red("✗ missing provider status file; pass --file <path>"));
+        process.exit(1);
+    }
+    const { target, config, workConfigPath, provider, providerConfig } = await loadWorkContext(opts, "import-status");
+    const inputFile = resolveInsideProject(target, opts.file, "provider status file");
+    const { ledgerPath } = await resolveWorkLedgerPath(target, config);
+    const existingEvents = await readWorkEvents(ledgerPath);
+    const records = await readProviderStatusRecords(inputFile);
+    const inverseStatusMapping = invertMapping(providerConfig.statusMapping ?? {});
+    const now = new Date().toISOString();
+    const baseItems = records.map((record) => {
+        const providerStatus = record.status ?? null;
+        const localStatus = providerStatus ? inverseStatusMapping[providerStatus] ?? null : null;
+        const blockedReasons = [];
+        const localId = record.localId ?? record.workItemId ?? record.id ?? null;
+        if (!localId)
+            blockedReasons.push("localId");
+        if (!providerStatus)
+            blockedReasons.push("status");
+        if (providerStatus && !localStatus)
+            blockedReasons.push(`unmapped status: ${providerStatus}`);
+        return {
+            localId,
+            remoteId: record.remoteId ?? null,
+            providerStatus,
+            localStatus,
+            updatedAt: record.updatedAt ?? null,
+            blockedReasons,
+            artifactTargets: [],
+            updatedArtifacts: [],
+            artifactNotes: [],
+        };
+    });
+    const items = await Promise.all(baseItems.map(async (item, index) => {
+        const record = records[index];
+        const previous = item.localId ? latestWorkItem(existingEvents, item.localId) : undefined;
+        const artifactPlan = await planLocalArtifactTargets({
+            target,
+            config,
+            record,
+            previous,
+            localId: item.localId,
+        });
+        return {
+            ...item,
+            artifactTargets: artifactPlan.targets,
+            artifactNotes: artifactPlan.notes,
+        };
+    }));
+    const blockedCount = items.filter((item) => item.blockedReasons.length > 0).length;
+    const evidenceDir = resolve(target, getWorkspacePath(config, "evidenceRoot"), "work-status-import", runId(now));
+    const jsonPath = join(evidenceDir, "status-import-plan.json");
+    const mdPath = join(evidenceDir, "status-import-plan.md");
+    const artifactUpdateCount = opts.dryRun
+        ? 0
+        : await applyStatusImportArtifacts({
+            target,
+            config,
+            provider,
+            importedAt: now,
+            items,
+        });
+    const importedEvents = opts.dryRun
+        ? []
+        : buildStatusImportEvents({
+            target,
+            provider,
+            inputFile,
+            evidencePath: jsonPath,
+            importedAt: now,
+            existingEvents,
+            items,
+        });
+    if (!opts.dryRun && importedEvents.length > 0) {
+        await appendWorkEvents(ledgerPath, importedEvents);
+    }
+    const localSideEffects = resolveStatusImportLocalSideEffects(Boolean(opts.dryRun), importedEvents.length, artifactUpdateCount);
+    const plan = {
+        version: 1,
+        dryRun: Boolean(opts.dryRun),
+        provider,
+        adapter: providerConfig.adapter ?? null,
+        generatedAt: now,
+        target,
+        workConfig: workConfigPath,
+        inputFile,
+        ledger: ledgerPath,
+        remoteSideEffects: "none",
+        localSideEffects,
+        itemCount: items.length,
+        mappedCount: items.length - blockedCount,
+        blockedCount,
+        appendedCount: importedEvents.length,
+        artifactUpdateCount,
+        items,
+    };
+    await mkdir(evidenceDir, { recursive: true });
+    await writeFile(jsonPath, `${JSON.stringify(plan, null, 2)}\n`, "utf8");
+    await writeFile(mdPath, renderStatusImportPlan(plan), "utf8");
+    if (opts.json) {
+        console.log(JSON.stringify({ plan, artifacts: { json: jsonPath, markdown: mdPath } }, null, 2));
+        return;
+    }
+    console.log(pc.green(`✓ zsk work import-status ${opts.dryRun ? "dry-run " : ""}completed`));
+    console.log(pc.dim(`provider: ${provider}`));
+    console.log(pc.dim(`input: ${inputFile}`));
+    console.log(pc.dim(`items: ${plan.itemCount}; mapped: ${plan.mappedCount}; blocked: ${plan.blockedCount}`));
+    console.log(pc.dim("remote side effects: none"));
+    console.log(pc.dim(`local side effects: ${plan.localSideEffects}`));
+    console.log(pc.dim(`ledger: ${ledgerPath}${plan.appendedCount > 0 ? ` (${plan.appendedCount} appended)` : ""}`));
+    if (plan.artifactUpdateCount > 0)
+        console.log(pc.dim(`artifacts updated: ${plan.artifactUpdateCount}`));
+    console.log(pc.dim(`status import plan: ${jsonPath}`));
+    console.log(pc.dim(`summary: ${mdPath}`));
+}
+export async function importExperts(opts = {}) {
+    if (!opts.file) {
+        console.error(pc.red("✗ missing provider expert export; pass --file <path>"));
+        process.exit(1);
+    }
+    const { target, config, workConfigPath, provider, providerConfig } = await loadWorkContext(opts, "import-experts");
+    const teamConfigPath = resolveInsideProject(target, config.customize?.team ?? ".zsk/team.yaml", "team config");
+    const teamConfig = await readTeamConfig(teamConfigPath);
+    const inputFile = resolveInsideProject(target, opts.file, "provider expert export");
+    const outputFile = resolveInsideProject(target, resolveExpertCatalogOutput(provider, providerConfig, teamConfig, opts.out), "provider expert catalog");
+    const outputRel = projectRelative(target, outputFile);
+    const raw = YAML.parse(await readFile(inputFile, "utf8"));
+    const generatedAt = new Date().toISOString();
+    const items = providerExpertPlanItems(raw);
+    const validItems = items.filter((item) => item.blockedReasons.length === 0);
+    const catalog = buildProviderExpertCatalog(provider, generatedAt, validItems);
+    const blockedCount = items.length - validItems.length;
+    const outputConfigured = expertCatalogPathIsConfigured(outputRel, provider, providerConfig, teamConfig);
+    const evidenceDir = resolve(target, getWorkspacePath(config, "evidenceRoot"), "work-expert-import", runId(generatedAt));
+    const jsonPath = join(evidenceDir, "expert-import-plan.json");
+    const mdPath = join(evidenceDir, "expert-import-plan.md");
+    const plan = {
+        version: 1,
+        dryRun: Boolean(opts.dryRun),
+        provider,
+        adapter: providerConfig.adapter ?? null,
+        generatedAt,
+        target,
+        workConfig: workConfigPath,
+        teamConfig: teamConfigPath,
+        inputFile,
+        outputFile,
+        outputConfigured,
+        remoteSideEffects: "none",
+        localSideEffects: !opts.dryRun && validItems.length > 0 ? "write-provider-expert-catalog" : "none",
+        itemCount: items.length,
+        normalizedCount: validItems.length,
+        blockedCount,
+        writtenCount: opts.dryRun ? 0 : validItems.length,
+        catalog,
+        items,
+        qualityGates: expertImportQualityGates(items, validItems.length, outputConfigured, Boolean(opts.dryRun)),
+    };
+    await mkdir(evidenceDir, { recursive: true });
+    if (!opts.dryRun && validItems.length > 0) {
+        await mkdir(resolve(outputFile, ".."), { recursive: true });
+        await writeFile(outputFile, YAML.stringify(catalog), "utf8");
+    }
+    await writeFile(jsonPath, `${JSON.stringify(plan, null, 2)}\n`, "utf8");
+    await writeFile(mdPath, renderExpertImportPlan(plan), "utf8");
+    if (opts.json) {
+        console.log(JSON.stringify({ plan, artifacts: { json: jsonPath, markdown: mdPath, catalog: outputFile } }, null, 2));
+        return;
+    }
+    console.log(pc.green(`✓ zsk work import-experts ${opts.dryRun ? "dry-run " : ""}completed`));
+    console.log(pc.dim(`provider: ${provider}`));
+    console.log(pc.dim(`input: ${inputFile}`));
+    console.log(pc.dim(`catalog: ${outputFile}${outputConfigured ? "" : " (auto-discovered default path)"}`));
+    console.log(pc.dim(`experts: ${plan.itemCount}; normalized: ${plan.normalizedCount}; blocked: ${plan.blockedCount}`));
+    console.log(pc.dim("remote side effects: none"));
+    console.log(pc.dim(`local side effects: ${plan.localSideEffects}`));
+    console.log(pc.dim(`expert import plan: ${jsonPath}`));
+    console.log(pc.dim(`summary: ${mdPath}`));
+}
+export async function emitTasks(opts = {}) {
+    const { target, config, workConfigPath, provider, providerConfig } = await loadWorkContext(opts, "emit-tasks");
+    const moduleId = opts.module ?? inferModuleFromTaskPath(target, config, opts.tasks);
+    if (!moduleId) {
+        console.error(pc.red("✗ missing module id; pass -m <module-id> or --tasks <module-tasks.md>"));
+        process.exit(1);
+    }
+    const taskArtifactRel = opts.tasks ?? join(getWorkspacePath(config, "moduleRoot", { module: moduleId }), "tasks.md");
+    const taskArtifactPath = resolveInsideProject(target, taskArtifactRel, "tasks artifact");
+    if (!isAllowedTaskArtifact(target, config, taskArtifactPath)) {
+        console.error(pc.red(`✗ tasks artifact must be a module tasks.md file: ${taskArtifactRel}`));
+        process.exit(1);
+    }
+    const { ledgerPath } = await resolveWorkLedgerPath(target, config);
+    const existingEvents = await readWorkEvents(ledgerPath);
+    const now = new Date().toISOString();
+    const evidenceDir = resolve(target, getWorkspacePath(config, "evidenceRoot"), "work-task-emit", runId(now));
+    const jsonPath = join(evidenceDir, "task-emit-plan.json");
+    const mdPath = join(evidenceDir, "task-emit-plan.md");
+    const tasksContent = await readFile(taskArtifactPath, "utf8");
+    const parsedItems = parseTaskWorkItems({
+        target,
+        providerConfig,
+        taskArtifactPath,
+        content: tasksContent,
+        moduleId,
+        projectId: opts.project,
+        stage: opts.stage ?? "task",
+        existingEvents,
+    });
+    const events = buildTaskEmitEvents({
+        items: parsedItems,
+        emittedAt: now,
+        evidencePath: projectRelative(target, jsonPath),
+    });
+    const appendedCount = opts.dryRun ? 0 : events.length;
+    const plan = {
+        version: 1,
+        dryRun: Boolean(opts.dryRun),
+        provider,
+        adapter: providerConfig.adapter ?? null,
+        generatedAt: now,
+        target,
+        workConfig: workConfigPath,
+        ledger: ledgerPath,
+        tasksArtifact: projectRelative(target, taskArtifactPath),
+        remoteSideEffects: "none",
+        localSideEffects: appendedCount > 0 ? "append-work-ledger" : "none",
+        itemCount: parsedItems.length,
+        appendableCount: events.length,
+        blockedCount: parsedItems.filter((item) => item.blockedReasons.length > 0).length,
+        skippedCount: parsedItems.filter((item) => item.skipReason).length,
+        appendedCount,
+        items: parsedItems,
+        qualityGates: taskEmitQualityGates(parsedItems, events.length, Boolean(opts.dryRun)),
+    };
+    await mkdir(evidenceDir, { recursive: true });
+    if (!opts.dryRun && events.length > 0) {
+        await appendWorkEvents(ledgerPath, events);
+    }
+    await writeFile(jsonPath, `${JSON.stringify(plan, null, 2)}\n`, "utf8");
+    await writeFile(mdPath, renderTaskEmitPlan(plan), "utf8");
+    if (opts.json) {
+        console.log(JSON.stringify({ plan, artifacts: { json: jsonPath, markdown: mdPath } }, null, 2));
+        return;
+    }
+    console.log(pc.green(`✓ zsk work emit-tasks ${opts.dryRun ? "dry-run " : ""}completed`));
+    console.log(pc.dim(`provider: ${provider}`));
+    console.log(pc.dim(`tasks: ${taskArtifactPath}`));
+    console.log(pc.dim(`items: ${plan.itemCount}; appendable: ${plan.appendableCount}; blocked: ${plan.blockedCount}; skipped: ${plan.skippedCount}`));
+    console.log(pc.dim("remote side effects: none"));
+    console.log(pc.dim(`local side effects: ${plan.localSideEffects}`));
+    console.log(pc.dim(`ledger: ${ledgerPath}${plan.appendedCount > 0 ? ` (${plan.appendedCount} appended)` : ""}`));
+    console.log(pc.dim(`task emit plan: ${jsonPath}`));
+    console.log(pc.dim(`summary: ${mdPath}`));
+}
+function buildSyncPlan(input) {
+    const items = input.events.map((event, index) => planItem(index + 1, event, input.provider, input.providerConfig));
+    const providerConfigured = providerLooksConfigured(input.providerConfig);
+    const blockedCount = items.filter((item) => !item.remoteReady).length;
+    const actionableCount = items.length - blockedCount;
+    const providerCommandPlan = buildProviderCommandPlan({
+        provider: input.provider,
+        providerConfig: input.providerConfig,
+        providerConfigured,
+        items,
+        events: input.events,
+    });
+    return {
+        version: 1,
+        dryRun: true,
+        provider: input.provider,
+        adapter: input.providerConfig.adapter ?? null,
+        generatedAt: input.generatedAt,
+        target: input.target,
+        workConfig: input.workConfigPath,
+        ledger: input.ledgerPath,
+        providerConfigured,
+        remoteSideEffects: "none",
+        eventCount: input.events.length,
+        actionableCount,
+        blockedCount,
+        items,
+        providerCommandPlan,
+        qualityGates: [
+            {
+                id: "provider-configured",
+                status: providerConfigured ? "pass" : "fail",
+                detail: providerConfigured ? "provider has a non-placeholder workspace/config" : "provider config is placeholder-only",
+            },
+            {
+                id: "dry-run-only",
+                status: "pass",
+                detail: "no provider command or API call was executed",
+            },
+            {
+                id: "event-schema",
+                status: blockedCount === 0 ? "pass" : "fail",
+                detail: blockedCount === 0 ? "all events have required sync fields" : `${blockedCount} event(s) need missing fields before remote sync`,
+            },
+            {
+                id: "provider-command-plan",
+                status: providerCommandPlan.blockedCount === 0 ? "pass" : "fail",
+                detail: providerCommandPlan.blockedCount === 0
+                    ? `${providerCommandPlan.commandCount} provider command(s) planned without execution`
+                    : `${providerCommandPlan.blockedCount} provider command(s) need missing fields before execution`,
+            },
+        ],
+    };
+}
+function planItem(line, event, provider, providerConfig) {
+    const workItem = event.workItem ?? {};
+    const localStatus = event.status?.to ?? workItem.status ?? null;
+    const blockedReasons = requiredWorkItemGaps(event);
+    return {
+        line,
+        event: event.event ?? "unknown",
+        action: actionForEvent(event.event),
+        localId: workItem.id ?? null,
+        project: idOf(workItem.project),
+        module: idOf(workItem.module),
+        stage: workItem.stage ?? event.producer?.stage ?? null,
+        localStatus,
+        providerStatus: localStatus ? providerConfig.statusMapping?.[localStatus] ?? null : null,
+        remoteRef: workItem.externalRefs?.[provider] ?? null,
+        remoteReady: blockedReasons.length === 0,
+        blockedReasons,
+    };
+}
+function actionForEvent(event) {
+    switch (event) {
+        case "work.provider_status.imported":
+            return "record-provider-status-import";
+        case "work.item.upserted":
+            return "create-or-update-work-item";
+        case "work.item.linked":
+            return "update-links";
+        case "work.item.status_changed":
+            return "update-status";
+        case "work.assignment.requested":
+            return "request-assignment";
+        case "work.assignment.accepted":
+            return "confirm-assignment";
+        case "work.comment.added":
+            return "add-comment";
+        case "work.item.verified":
+            return "mark-verified";
+        case "work.item.blocked":
+            return "mark-blocked";
+        default:
+            return "inspect-only";
+    }
+}
+function requiredWorkItemGaps(event) {
+    if (event.event === "work.provider_status.imported") {
+        return requiredProviderStatusImportGaps(event);
+    }
+    const gaps = [];
+    if (!event.event)
+        gaps.push("event");
+    if (!event.producer?.skill)
+        gaps.push("producer.skill");
+    if (!event.producer?.stage)
+        gaps.push("producer.stage");
+    const workItem = event.workItem;
+    if (!workItem?.id)
+        gaps.push("workItem.id");
+    if (!workItem?.type)
+        gaps.push("workItem.type");
+    if (!workItem?.title)
+        gaps.push("workItem.title");
+    if (!idOf(workItem?.project))
+        gaps.push("workItem.project");
+    if (!idOf(workItem?.module))
+        gaps.push("workItem.module");
+    if (!workItem?.stage && !event.producer?.stage)
+        gaps.push("workItem.stage");
+    if (!workItem?.status && !event.status?.to)
+        gaps.push("workItem.status");
+    if (!Array.isArray(workItem?.sourceArtifacts) || workItem.sourceArtifacts.length === 0) {
+        gaps.push("workItem.sourceArtifacts");
+    }
+    return gaps;
+}
+function requiredProviderStatusImportGaps(event) {
+    const gaps = [];
+    if (!event.event)
+        gaps.push("event");
+    if (!event.producer?.skill)
+        gaps.push("producer.skill");
+    if (!event.producer?.stage)
+        gaps.push("producer.stage");
+    if (!event.workItem?.id)
+        gaps.push("workItem.id");
+    if (!event.status?.to)
+        gaps.push("status.to");
+    if (typeof event.status?.providerStatus !== "string")
+        gaps.push("status.providerStatus");
+    return gaps;
+}
+async function readWorkConfig(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = YAML.parse(raw);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        console.error(pc.red(`✗ work config not found: ${path}`));
+        process.exit(1);
+    }
+}
+function renderSyncPlan(plan) {
+    const rows = plan.items.map((item) => [
+        item.line,
+        item.event,
+        item.action,
+        item.localId ?? "",
+        item.project ?? "",
+        item.module ?? "",
+        item.localStatus ?? "",
+        item.providerStatus ?? "",
+        item.remoteReady ? "yes" : item.blockedReasons.join(", "),
+    ].join(" | "));
+    const commandRows = plan.providerCommandPlan.commands.map((command) => [
+        command.line,
+        command.action,
+        command.operation,
+        command.ready ? "yes" : command.blockedReasons.join(", "),
+        commandDisplayWithMetadata(command),
+    ].join(" | "));
+    return [
+        "# Work Sync Dry Run",
+        "",
+        `- Provider: ${plan.provider}`,
+        `- Adapter: ${plan.adapter ?? "unknown"}`,
+        `- Generated at: ${plan.generatedAt}`,
+        `- Work config: ${plan.workConfig}`,
+        `- Ledger: ${plan.ledger}`,
+        `- Remote side effects: ${plan.remoteSideEffects}`,
+        `- Events: ${plan.eventCount}`,
+        `- Actionable: ${plan.actionableCount}`,
+        `- Blocked: ${plan.blockedCount}`,
+        `- Provider command executable: ${plan.providerCommandPlan.executable}`,
+        `- Provider commands: ${plan.providerCommandPlan.commandCount}`,
+        `- Provider command blockers: ${plan.providerCommandPlan.blockedCount}`,
+        "",
+        "## Quality Gates",
+        "",
+        ...plan.qualityGates.map((gate) => `- ${gate.id}: ${gate.status} - ${gate.detail}`),
+        "",
+        "## Planned Provider Operations",
+        "",
+        "line | event | action | local id | project | module | local status | provider status | remote ready",
+        "--- | --- | --- | --- | --- | --- | --- | --- | ---",
+        ...(rows.length > 0 ? rows : [" | | | | | | | | no events"]),
+        "",
+        "## Provider Command Plan",
+        "",
+        "line | action | operation | ready | command / note",
+        "--- | --- | --- | --- | ---",
+        ...(commandRows.length > 0 ? commandRows : [" | | | | no provider commands"]),
+        "",
+    ].join("\n");
+}
+async function loadWorkContext(opts, action) {
+    const target = opts.target ? resolvePath(opts.target) : process.cwd();
+    const configCheck = await checkProjectConfig(target);
+    for (const warning of configCheck.warnings) {
+        console.warn(pc.yellow(`! ${warning.file}: ${warning.message}`));
+    }
+    if (!configCheck.ok) {
+        console.error(pc.red(`✗ zsk work ${action} stopped: config check failed`));
+        process.exit(1);
+    }
+    const config = await readProjectConfig(target);
+    const workConfigRel = config.customize?.work ?? ".zsk/work.yaml";
+    const workConfigPath = resolveInsideProject(target, workConfigRel, "work config");
+    const workConfig = await readWorkConfig(workConfigPath);
+    const provider = opts.provider ?? workConfig.defaultProvider ?? "multica";
+    const providerConfig = workConfig.providers?.[provider];
+    if (!providerConfig) {
+        console.error(pc.red(`✗ work provider not configured: ${provider}`));
+        console.error(pc.dim(`configured providers: ${Object.keys(workConfig.providers ?? {}).join(", ") || "none"}`));
+        process.exit(1);
+    }
+    return { target, config, workConfigPath, workConfig, provider, providerConfig };
+}
+function resolveAssignment(opts, provider, teamConfig) {
+    const mode = opts.agent ? "agent" : opts.squad ? "squad" : "role";
+    const inferredRole = opts.role ?? inferRole(opts, teamConfig);
+    if (!inferredRole) {
+        console.error(pc.red("✗ unable to infer assignment role; pass --role <id>"));
+        process.exit(1);
+    }
+    if (!teamConfig.roles?.[inferredRole]) {
+        console.error(pc.red(`✗ unknown role in .zsk/team.yaml: ${inferredRole}`));
+        process.exit(1);
+    }
+    if (opts.agent && !teamConfig.agents?.[opts.agent]) {
+        console.error(pc.red(`✗ unknown agent in .zsk/team.yaml: ${opts.agent}`));
+        process.exit(1);
+    }
+    if (opts.squad && !teamConfig.squads?.[opts.squad]) {
+        console.error(pc.red(`✗ unknown squad in .zsk/team.yaml: ${opts.squad}`));
+        process.exit(1);
+    }
+    const providerAgent = opts.agent
+        ? teamConfig.agents?.[opts.agent]?.providerRefs?.[provider]?.agent ?? null
+        : opts.squad
+            ? providerAgentForSquad(opts.squad, provider, teamConfig)
+            : null;
+    return {
+        mode,
+        role: inferredRole,
+        agent: opts.agent ?? null,
+        squad: opts.squad ?? null,
+        providerAgent,
+        rationale: opts.reason ?? "assignment requested by zsk work assign",
+    };
+}
+function inferRole(opts, teamConfig) {
+    if (opts.agent) {
+        const roles = teamConfig.agents?.[opts.agent]?.roles ?? [];
+        return roles.length === 1 ? roles[0] ?? null : null;
+    }
+    if (opts.squad) {
+        const leader = teamConfig.squads?.[opts.squad]?.leader;
+        const roles = leader ? teamConfig.agents?.[leader]?.roles ?? [] : [];
+        return roles[0] ?? null;
+    }
+    return opts.role ?? null;
+}
+function providerAgentForSquad(squad, provider, teamConfig) {
+    const leader = teamConfig.squads?.[squad]?.leader;
+    if (!leader)
+        return null;
+    return teamConfig.agents?.[leader]?.providerRefs?.[provider]?.agent ?? null;
+}
+function resolveAssignmentWorkItem(opts, providerConfig, previous) {
+    const moduleId = opts.module ?? idOf(previous?.module);
+    return {
+        id: opts.item,
+        project: resolveWorkProject(opts.project, moduleId, providerConfig) ?? idOf(previous?.project),
+        module: moduleId ?? null,
+        stage: opts.stage ?? previous?.stage ?? null,
+    };
+}
+function resolveWorkProject(project, moduleId, providerConfig) {
+    if (project?.trim())
+        return project.trim();
+    const module = moduleId?.trim();
+    if (!module)
+        return null;
+    const mapped = providerConfig.projectMapping?.projects?.[module];
+    if (mapped?.trim())
+        return mapped.trim();
+    return providerConfig.projectMapping?.strategy === "module-to-project" ? module : null;
+}
+function inferModuleFromTaskPath(target, config, taskPath) {
+    if (!taskPath)
+        return null;
+    const resolved = resolveProjectPath(target, taskPath);
+    const modulesRoot = resolve(target, getWorkspacePath(config, "modulesRoot"));
+    if (!isPathInside(modulesRoot, resolved))
+        return null;
+    const [moduleId] = toPosix(relative(modulesRoot, resolved)).split("/");
+    return moduleId?.trim() || null;
+}
+function assignmentQualityGates(assignment, teamConfig, providerConfigured, providerCommandPlan) {
+    return [
+        {
+            id: "provider-configured",
+            status: providerConfigured ? "pass" : "fail",
+            detail: providerConfigured ? "provider has a non-placeholder workspace/config" : "provider config is placeholder-only",
+        },
+        {
+            id: "role-exists",
+            status: teamConfig.roles?.[assignment.role] ? "pass" : "fail",
+            detail: assignment.role,
+        },
+        {
+            id: "assignee-exists",
+            status: assignment.mode === "role" ||
+                (assignment.agent ? Boolean(teamConfig.agents?.[assignment.agent]) : Boolean(teamConfig.squads?.[assignment.squad ?? ""]))
+                ? "pass"
+                : "fail",
+            detail: assignment.agent ?? assignment.squad ?? assignment.role,
+        },
+        {
+            id: "provider-command-plan",
+            status: providerCommandPlan.blockedCount === 0 ? "pass" : "fail",
+            detail: providerCommandPlan.blockedCount === 0
+                ? `${providerCommandPlan.commandCount} provider command(s) planned without execution`
+                : `${providerCommandPlan.blockedCount} provider command blocker(s): ${providerCommandPlan.commands.flatMap((command) => command.blockedReasons).join(", ")}`,
+        },
+        {
+            id: "provider-side-effects",
+            status: "pass",
+            detail: "no provider command or API call was executed; non-dry-run only appends a local assignment event",
+        },
+    ];
+}
+function renderAssignmentPlan(plan) {
+    const commandRows = plan.providerCommandPlan.commands.map((command) => [
+        command.line,
+        command.action,
+        command.operation,
+        command.ready ? "yes" : command.blockedReasons.join(", "),
+        commandDisplayWithMetadata(command),
+    ].join(" | "));
+    return [
+        `# Work Assignment${plan.dryRun ? " Dry Run" : ""}`,
+        "",
+        `- Provider: ${plan.provider}`,
+        `- Adapter: ${plan.adapter ?? "unknown"}`,
+        `- Ledger: ${plan.ledger}`,
+        `- Work item: ${plan.workItem.id}`,
+        `- Project: ${plan.workItem.project ?? ""}`,
+        `- Module: ${plan.workItem.module ?? ""}`,
+        `- Stage: ${plan.workItem.stage ?? ""}`,
+        `- Mode: ${plan.assignment.mode}`,
+        `- Role: ${plan.assignment.role}`,
+        `- Agent: ${plan.assignment.agent ?? ""}`,
+        `- Squad: ${plan.assignment.squad ?? ""}`,
+        `- Provider agent: ${plan.assignment.providerAgent ?? ""}`,
+        `- Rationale: ${plan.assignment.rationale}`,
+        `- Remote side effects: ${plan.remoteSideEffects}`,
+        `- Local side effects: ${plan.localSideEffects}`,
+        `- Appended: ${plan.appendedCount}`,
+        `- Provider command executable: ${plan.providerCommandPlan.executable}`,
+        `- Provider commands: ${plan.providerCommandPlan.commandCount}`,
+        `- Provider command blockers: ${plan.providerCommandPlan.blockedCount}`,
+        "",
+        "## Quality Gates",
+        "",
+        ...plan.qualityGates.map((gate) => `- ${gate.id}: ${gate.status} - ${gate.detail}`),
+        "",
+        "## Provider Command Plan",
+        "",
+        "line | action | operation | ready | command / note",
+        "--- | --- | --- | --- | ---",
+        ...(commandRows.length > 0 ? commandRows : [" | | | | no provider commands"]),
+        "",
+    ].join("\n");
+}
+async function readTeamConfig(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = YAML.parse(raw);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        console.error(pc.red(`✗ team config not found: ${path}`));
+        process.exit(1);
+    }
+}
+async function readProviderStatusRecords(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = YAML.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed.filter(isRecord);
+        if (isRecord(parsed) && Array.isArray(parsed.items))
+            return parsed.items.filter(isRecord);
+        if (isRecord(parsed))
+            return [parsed];
+        return [];
+    }
+    catch {
+        console.error(pc.red(`✗ provider status file not found: ${path}`));
+        process.exit(1);
+    }
+}
+function providerExpertPlanItems(value) {
+    return providerExpertRecords(value).map((record, index) => {
+        const sourceId = firstString(record.id, record.agentId, record.providerAgent, record.agent, record.username, record.handle, record.slug, record.name);
+        const providerAgent = firstString(record.providerAgent, record.agent, record.username, record.handle, record.slug, record.id, record.name);
+        const id = normalizeExpertId(firstString(record.id, record.agentId, record.slug, record.username, record.handle, record.name, providerAgent) ?? `expert-${index + 1}`);
+        const roles = uniqueStrings([
+            ...stringListOf(record.roles),
+            ...stringListOf(record.role),
+            ...stringListOf(record.roleIds),
+            ...stringListOf(record.roleNames),
+        ]);
+        const stages = uniqueStrings([
+            ...stringListOf(record.stages),
+            ...stringListOf(record.stage),
+            ...stringListOf(record.stageIds),
+            ...stringListOf(record.stageNames),
+        ]);
+        const modules = uniqueStrings([
+            ...stringListOf(record.modules),
+            ...stringListOf(record.module),
+            ...stringListOf(record.moduleIds),
+            ...stringListOf(record.projects),
+            ...stringListOf(record.projectIds),
+        ]);
+        const subagentTypes = uniqueStrings([
+            ...stringListOf(record.subagentTypes),
+            ...stringListOf(record.subagents),
+            ...stringListOf(record.agentTypes),
+            ...stringListOf(record.capabilities),
+        ]);
+        const priority = numberOf(record.priority);
+        const capacity = stringOf(record.capacity) ?? numberOf(record.capacity);
+        const blockedReasons = [];
+        if (!id)
+            blockedReasons.push("expert.id");
+        if (!providerAgent)
+            blockedReasons.push("expert.providerAgent");
+        if (roles.length === 0)
+            blockedReasons.push("expert.roles");
+        return {
+            sourceId,
+            id,
+            providerAgent,
+            roles,
+            stages,
+            modules,
+            subagentTypes,
+            capacity,
+            priority,
+            blockedReasons,
+        };
+    });
+}
+function providerExpertRecords(value) {
+    if (Array.isArray(value))
+        return value.filter(isRecord);
+    if (!isRecord(value))
+        return [];
+    for (const key of ["experts", "agents", "members", "users", "items", "records", "data"]) {
+        const item = value[key];
+        if (Array.isArray(item))
+            return item.filter(isRecord);
+        if (isRecord(item)) {
+            return Object.entries(item)
+                .filter(([, record]) => isRecord(record))
+                .map(([id, record]) => ({ id, ...record }));
+        }
+    }
+    return [value];
+}
+function buildProviderExpertCatalog(provider, generatedAt, items) {
+    return {
+        version: 1,
+        provider,
+        generatedAt,
+        experts: items.map((item) => compactRecord({
+            id: item.id,
+            providerAgent: item.providerAgent,
+            roles: item.roles,
+            stages: item.stages,
+            modules: item.modules,
+            subagentTypes: item.subagentTypes,
+            capacity: item.capacity,
+            priority: item.priority,
+            providerRefs: item.providerAgent ? { [provider]: { agent: item.providerAgent } } : undefined,
+        })),
+    };
+}
+function resolveExpertCatalogOutput(provider, providerConfig, teamConfig, out) {
+    return out ??
+        teamConfig.providerCatalogs?.[provider]?.path ??
+        providerConfig.expertCatalog?.path ??
+        `.zsk/providers/${provider}/experts.yaml`;
+}
+function expertCatalogPathIsConfigured(outputRel, provider, providerConfig, teamConfig) {
+    const configured = teamConfig.providerCatalogs?.[provider]?.path ?? providerConfig.expertCatalog?.path;
+    if (!configured)
+        return outputRel === `.zsk/providers/${provider}/experts.yaml`;
+    return toPosix(configured) === toPosix(outputRel);
+}
+function expertImportQualityGates(items, normalizedCount, outputConfigured, dryRun) {
+    const blockedCount = items.length - normalizedCount;
+    return [
+        {
+            id: "experts-normalized",
+            status: normalizedCount > 0 ? "pass" : "fail",
+            detail: normalizedCount > 0 ? `${normalizedCount} expert(s) ready for catalog` : "no valid experts with id, provider agent, and roles",
+        },
+        {
+            id: "blocked-experts",
+            status: blockedCount === 0 ? "pass" : "fail",
+            detail: blockedCount === 0 ? "all expert records are usable" : `${blockedCount} expert record(s) are missing required fields`,
+        },
+        {
+            id: "dispatch-readable-catalog",
+            status: outputConfigured ? "pass" : "fail",
+            detail: outputConfigured
+                ? "catalog path is configured or matches the dispatch auto-discovery path"
+                : "catalog path is not configured in .zsk/team.yaml or .zsk/work.yaml",
+        },
+        {
+            id: "provider-side-effects",
+            status: "pass",
+            detail: dryRun ? "dry-run only; no local or remote side effects" : "local catalog write only; no provider command or API call was executed",
+        },
+    ];
+}
+function renderExpertImportPlan(plan) {
+    const rows = plan.items.map((item) => [
+        item.sourceId ?? "",
+        item.id ?? "",
+        item.providerAgent ?? "",
+        item.roles.join(", "),
+        item.stages.join(", "),
+        item.modules.join(", "),
+        item.subagentTypes.join(", "),
+        item.blockedReasons.length === 0 ? "yes" : item.blockedReasons.join(", "),
+    ].join(" | "));
+    return [
+        `# Work Expert Import${plan.dryRun ? " Dry Run" : ""}`,
+        "",
+        `- Provider: ${plan.provider}`,
+        `- Adapter: ${plan.adapter ?? "unknown"}`,
+        `- Input: ${plan.inputFile}`,
+        `- Output: ${plan.outputFile}`,
+        `- Output configured: ${plan.outputConfigured ? "yes" : "no"}`,
+        `- Remote side effects: ${plan.remoteSideEffects}`,
+        `- Local side effects: ${plan.localSideEffects}`,
+        `- Items: ${plan.itemCount}`,
+        `- Normalized: ${plan.normalizedCount}`,
+        `- Blocked: ${plan.blockedCount}`,
+        `- Written: ${plan.writtenCount}`,
+        "",
+        "## Quality Gates",
+        "",
+        ...plan.qualityGates.map((gate) => `- ${gate.id}: ${gate.status} - ${gate.detail}`),
+        "",
+        "source id | id | provider agent | roles | stages | modules | subagent types | ready",
+        "--- | --- | --- | --- | --- | --- | --- | ---",
+        ...(rows.length > 0 ? rows : [" | | | | | | | no expert records"]),
+        "",
+    ].join("\n");
+}
+function renderStatusImportPlan(plan) {
+    const rows = plan.items.map((item) => [
+        item.localId ?? "",
+        item.remoteId ?? "",
+        item.providerStatus ?? "",
+        item.localStatus ?? "",
+        item.updatedAt ?? "",
+        item.blockedReasons.length === 0 ? "yes" : item.blockedReasons.join(", "),
+        renderArtifactImportCell(item),
+    ].join(" | "));
+    return [
+        `# Work Status Import${plan.dryRun ? " Dry Run" : ""}`,
+        "",
+        `- Provider: ${plan.provider}`,
+        `- Adapter: ${plan.adapter ?? "unknown"}`,
+        `- Input: ${plan.inputFile}`,
+        `- Ledger: ${plan.ledger}`,
+        `- Remote side effects: ${plan.remoteSideEffects}`,
+        `- Local side effects: ${plan.localSideEffects}`,
+        `- Items: ${plan.itemCount}`,
+        `- Mapped: ${plan.mappedCount}`,
+        `- Blocked: ${plan.blockedCount}`,
+        `- Appended: ${plan.appendedCount}`,
+        `- Artifact updates: ${plan.artifactUpdateCount}`,
+        "",
+        "local id | remote id | provider status | local status | updated at | import ready | artifacts",
+        "--- | --- | --- | --- | --- | --- | ---",
+        ...(rows.length > 0 ? rows : [" | | | | | no items | "]),
+        "",
+    ].join("\n");
+}
+function renderArtifactImportCell(item) {
+    if (item.updatedArtifacts.length > 0)
+        return item.updatedArtifacts.join(", ");
+    if (item.artifactTargets.length > 0)
+        return item.artifactTargets.map((target) => `target:${target}`).join(", ");
+    return item.artifactNotes.join("; ");
+}
+function parseTaskWorkItems(input) {
+    const sourceArtifact = projectRelative(input.target, input.taskArtifactPath);
+    const groups = taskGroupSections(input.content);
+    return groups.flatMap((group) => {
+        const metadata = taskGroupMetadata(group.body);
+        const localId = metadata["work item id"] ?? taskMarkerId(group.body);
+        const localStatus = localId ? taskMarkerStatus(group.body, localId) : null;
+        const project = resolveWorkProject(input.projectId, input.moduleId, input.providerConfig);
+        const blockedReasons = [];
+        if (!localId)
+            blockedReasons.push("workItem.id");
+        if (!localStatus)
+            blockedReasons.push("zsk-task-status.status");
+        if (!project)
+            blockedReasons.push("workItem.project");
+        if (!input.moduleId)
+            blockedReasons.push("workItem.module");
+        if (!input.stage)
+            blockedReasons.push("workItem.stage");
+        if (!sourceArtifact)
+            blockedReasons.push("workItem.sourceArtifacts");
+        const item = {
+            localId,
+            title: group.title,
+            itemKind: "task-group",
+            parentId: null,
+            sequence: group.sequence,
+            project,
+            module: input.moduleId,
+            stage: input.stage,
+            localStatus,
+            owner: metadata.owner ?? null,
+            scope: metadata["scope / files"] ?? metadata["scope/files"] ?? metadata.scope ?? null,
+            linkedRefs: metadata["linked fr/ac"] ?? metadata.source ?? null,
+            evidenceHook: metadata["evidence hook"] ?? metadata.evidence ?? null,
+            stopCondition: metadata["stop condition"] ?? null,
+            sourceArtifact,
+            blockedReasons,
+            willAppend: false,
+            linkWillAppend: false,
+            skipReason: null,
+        };
+        const items = [finalizeTaskEmitPlanItem(item, input.existingEvents)];
+        if (blockedReasons.length === 0 && localId && localStatus) {
+            items.push(...taskSubtaskSections(group.body).map((subtask) => {
+                const subtaskMetadata = taskItemMetadata(subtask.body);
+                const subtaskLocalId = subtaskMetadata["work item id"] ?? taskMarkerId(subtask.body) ?? `${localId}-${subtask.sequence.replace(/\./g, "-")}`;
+                const subtaskStatus = taskMarkerStatus(subtask.body, subtaskLocalId) ?? subtaskMetadata.status ?? localStatus;
+                const childBlockedReasons = [];
+                if (!subtaskLocalId)
+                    childBlockedReasons.push("workItem.id");
+                if (!subtaskStatus)
+                    childBlockedReasons.push("zsk-task-status.status");
+                if (!project)
+                    childBlockedReasons.push("workItem.project");
+                if (!input.moduleId)
+                    childBlockedReasons.push("workItem.module");
+                if (!input.stage)
+                    childBlockedReasons.push("workItem.stage");
+                if (!sourceArtifact)
+                    childBlockedReasons.push("workItem.sourceArtifacts");
+                if (!localId)
+                    childBlockedReasons.push("workItem.parentId");
+                const child = {
+                    localId: subtaskLocalId,
+                    title: subtask.title,
+                    itemKind: "subtask",
+                    parentId: localId,
+                    sequence: subtask.sequence,
+                    project,
+                    module: input.moduleId,
+                    stage: input.stage,
+                    localStatus: subtaskStatus,
+                    owner: subtaskMetadata.owner ?? item.owner,
+                    scope: subtaskMetadata["scope / files"] ?? subtaskMetadata["scope/files"] ?? subtaskMetadata.scope ?? item.scope,
+                    linkedRefs: subtaskMetadata["linked fr/ac"] ?? subtaskMetadata.source ?? subtaskMetadata.acceptance ?? item.linkedRefs,
+                    evidenceHook: subtaskMetadata["evidence hook"] ?? subtaskMetadata.evidence ?? item.evidenceHook,
+                    stopCondition: subtaskMetadata["stop condition"] ?? subtaskMetadata.acceptance ?? null,
+                    sourceArtifact,
+                    blockedReasons: childBlockedReasons,
+                    willAppend: false,
+                    linkWillAppend: false,
+                    skipReason: null,
+                };
+                return finalizeTaskEmitPlanItem(child, input.existingEvents);
+            }));
+        }
+        return items;
+    });
+}
+function finalizeTaskEmitPlanItem(item, existingEvents) {
+    if (item.blockedReasons.length > 0)
+        return item;
+    const previous = item.localId ? latestWorkItem(existingEvents, item.localId) : undefined;
+    if (previous && sameTaskWorkItem(previous, item)) {
+        return {
+            ...item,
+            linkWillAppend: item.itemKind === "subtask" && !hasParentChildLink(existingEvents, item),
+            skipReason: "unchanged from latest work item event",
+        };
+    }
+    return {
+        ...item,
+        willAppend: true,
+        linkWillAppend: item.itemKind === "subtask" && !hasParentChildLink(existingEvents, item),
+    };
+}
+function taskGroupSections(content) {
+    const lines = content.split(/\r?\n/);
+    const groups = [];
+    let current = null;
+    for (const line of lines) {
+        const match = line.match(/^- \[[ xX]\] (\d+)\.\s+(.+)$/);
+        if (match) {
+            if (current)
+                groups.push({ title: current.title, body: current.lines.join("\n"), sequence: current.sequence });
+            current = { title: match[2]?.trim() ?? "", lines: [line], sequence: match[1]?.trim() ?? "" };
+            continue;
+        }
+        if (current)
+            current.lines.push(line);
+    }
+    if (current)
+        groups.push({ title: current.title, body: current.lines.join("\n"), sequence: current.sequence });
+    return groups;
+}
+function taskGroupMetadata(body) {
+    return taskItemMetadata(body, true);
+}
+function taskItemMetadata(body, stopAtSubtask = false) {
+    const metadata = {};
+    for (const line of body.split(/\r?\n/)) {
+        if (stopAtSubtask && /^\s+- \[[ xX]\] \d+\.\d+(?:\.\d+)*\s+/.test(line))
+            break;
+        const match = line.match(/^\s*-\s+([^:]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        const key = match[1]?.trim().toLowerCase();
+        if (!key || key.startsWith("["))
+            continue;
+        metadata[key] = match[2]?.trim() ?? "";
+    }
+    return metadata;
+}
+function taskSubtaskSections(body) {
+    const lines = body.split(/\r?\n/);
+    const subtasks = [];
+    let current = null;
+    for (const line of lines) {
+        const match = line.match(/^\s+- \[[ xX]\] (\d+\.\d+(?:\.\d+)*)\s+(.+)$/);
+        if (match) {
+            if (current)
+                subtasks.push({ title: current.title, body: current.lines.join("\n"), sequence: current.sequence });
+            current = { title: match[2]?.trim() ?? "", lines: [line], sequence: match[1]?.trim() ?? "" };
+            continue;
+        }
+        if (current)
+            current.lines.push(line);
+    }
+    if (current)
+        subtasks.push({ title: current.title, body: current.lines.join("\n"), sequence: current.sequence });
+    return subtasks;
+}
+function taskMarkerId(body) {
+    const match = body.match(/<!--\s*zsk-task-status:start\s+([^\s]+)\s*-->/);
+    return match?.[1]?.trim() ?? null;
+}
+function taskMarkerStatus(body, localId) {
+    const marker = body.match(taskStatusMarkerRegex(localId))?.[0] ?? "";
+    const status = marker.match(/^\s*-\s+status:\s*(.+?)\s*$/m)?.[1]?.trim();
+    return status || null;
+}
+function sameTaskWorkItem(previous, item) {
+    return previous.id === item.localId &&
+        previous.type === "task" &&
+        previous.title === item.title &&
+        previous.itemKind === item.itemKind &&
+        previous.parentId === item.parentId &&
+        previous.sequence === item.sequence &&
+        idOf(previous.project) === item.project &&
+        idOf(previous.module) === item.module &&
+        previous.stage === item.stage &&
+        previous.status === item.localStatus &&
+        stringsOf(previous.sourceArtifacts).includes(item.sourceArtifact) &&
+        previous.owner === item.owner &&
+        previous.scope === item.scope &&
+        previous.linkedRefs === item.linkedRefs &&
+        previous.evidenceHook === item.evidenceHook &&
+        previous.stopCondition === item.stopCondition;
+}
+function hasParentChildLink(events, item) {
+    if (!item.localId || !item.parentId)
+        return false;
+    return events.some((event) => event.event === "work.item.linked" &&
+        event.workItem?.id === item.localId &&
+        event.links?.relation === "parent-child" &&
+        event.links?.parentId === item.parentId &&
+        event.links?.childId === item.localId);
+}
+function buildTaskEmitEvents(input) {
+    return input.items.flatMap((item) => {
+        if (!item.localId || !item.localStatus || !item.project || !item.module)
+            return [];
+        const workItem = {
+            id: item.localId,
+            type: "task",
+            title: item.title,
+            project: item.project,
+            module: item.module,
+            stage: item.stage,
+            status: item.localStatus,
+            sourceArtifacts: [item.sourceArtifact],
+            owner: item.owner,
+            scope: item.scope,
+            linkedRefs: item.linkedRefs,
+            evidenceHook: item.evidenceHook,
+            stopCondition: item.stopCondition,
+            itemKind: item.itemKind,
+            parentId: item.parentId,
+            sequence: item.sequence,
+        };
+        const events = [];
+        if (item.willAppend) {
+            events.push({
+                event: "work.item.upserted",
+                version: 1,
+                occurredAt: input.emittedAt,
+                producer: {
+                    skill: "task",
+                    stage: "task",
+                },
+                workItem,
+                links: {
+                    taskArtifact: item.sourceArtifact,
+                    linkedRefs: item.linkedRefs,
+                    parentId: item.parentId,
+                },
+                evidence: {
+                    taskEmitPlan: input.evidencePath,
+                },
+            });
+        }
+        if (item.linkWillAppend && item.itemKind === "subtask" && item.parentId) {
+            events.push({
+                event: "work.item.linked",
+                version: 1,
+                occurredAt: input.emittedAt,
+                producer: {
+                    skill: "task",
+                    stage: "task",
+                },
+                workItem,
+                links: {
+                    relation: "parent-child",
+                    parentId: item.parentId,
+                    childId: item.localId,
+                    taskArtifact: item.sourceArtifact,
+                    linkedRefs: item.linkedRefs,
+                },
+                evidence: {
+                    taskEmitPlan: input.evidencePath,
+                },
+            });
+        }
+        return events;
+    });
+}
+function buildAssignmentEvents(input) {
+    if (input.providerCommandPlan.blockedCount > 0)
+        return [];
+    const latestAssignment = latestAssignmentEvent(input.existingEvents, input.workItem.id);
+    if (latestAssignment && sameAssignmentEvent(latestAssignment, input.assignment, input.provider))
+        return [];
+    const evidencePath = projectRelative(input.target, input.evidencePath);
+    const sourceArtifacts = uniqueStrings([
+        ...stringsOf(input.previous?.sourceArtifacts),
+        evidencePath,
+    ]);
+    const externalRefs = isRecord(input.previous?.externalRefs) ? { ...input.previous.externalRefs } : {};
+    const assignee = input.assignment.providerAgent ?? input.assignment.agent ?? input.assignment.squad ?? null;
+    const providerRefs = {};
+    if (input.assignment.providerAgent) {
+        providerRefs[input.provider] = { agent: input.assignment.providerAgent };
+    }
+    else if (input.assignment.agent) {
+        providerRefs[input.provider] = { agent: input.assignment.agent };
+    }
+    else if (input.assignment.squad) {
+        providerRefs[input.provider] = { squad: input.assignment.squad };
+    }
+    return [{
+            event: "work.assignment.requested",
+            version: 1,
+            occurredAt: input.assignedAt,
+            producer: {
+                skill: "work",
+                stage: "assign",
+            },
+            workItem: {
+                id: input.workItem.id,
+                type: input.previous?.type ?? "task",
+                title: input.previous?.title ?? `Assignment requested for ${input.workItem.id}`,
+                project: input.workItem.project,
+                module: input.workItem.module,
+                stage: input.workItem.stage,
+                status: input.previous?.status ?? "ready",
+                sourceArtifacts,
+                externalRefs,
+                owner: assignee,
+            },
+            assignment: {
+                mode: input.assignment.mode,
+                role: input.assignment.role,
+                agent: input.assignment.agent,
+                squad: input.assignment.squad,
+                providerAgent: input.assignment.providerAgent,
+                assignee,
+                providerRefs,
+                rationale: input.assignment.rationale,
+                requestedAt: input.assignedAt,
+            },
+            links: {
+                provider: input.provider,
+                assignmentPlan: evidencePath,
+            },
+            evidence: {
+                assignmentPlan: evidencePath,
+            },
+        }];
+}
+function taskEmitQualityGates(items, appendableCount, dryRun) {
+    const blockedCount = items.filter((item) => item.blockedReasons.length > 0).length;
+    return [
+        {
+            id: "task-marker-schema",
+            status: blockedCount === 0 ? "pass" : "fail",
+            detail: blockedCount === 0 ? "all task groups and subtasks have work item ids and statuses" : `${blockedCount} task item(s) need work item ids or statuses`,
+        },
+        {
+            id: "append-plan",
+            status: appendableCount > 0 || items.length > 0 ? "pass" : "fail",
+            detail: appendableCount > 0
+                ? `${appendableCount} work item event(s) ready to append`
+                : "no changed task work item events to append",
+        },
+        {
+            id: "remote-side-effects",
+            status: "pass",
+            detail: dryRun ? "dry-run only; no local or remote side effects" : "local ledger append only; no provider command or API call was executed",
+        },
+    ];
+}
+function renderTaskEmitPlan(plan) {
+    const rows = plan.items.map((item) => [
+        item.localId ?? "",
+        item.itemKind,
+        item.parentId ?? "",
+        item.title,
+        item.project ?? "",
+        item.module ?? "",
+        item.stage,
+        item.localStatus ?? "",
+        item.willAppend || item.linkWillAppend ? "yes" : item.skipReason ?? item.blockedReasons.join(", "),
+    ].join(" | "));
+    return [
+        "# Work Task Emit Plan",
+        "",
+        `- Provider: ${plan.provider}`,
+        `- Adapter: ${plan.adapter ?? "unknown"}`,
+        `- Generated at: ${plan.generatedAt}`,
+        `- Work config: ${plan.workConfig}`,
+        `- Ledger: ${plan.ledger}`,
+        `- Tasks artifact: ${plan.tasksArtifact}`,
+        `- Remote side effects: ${plan.remoteSideEffects}`,
+        `- Local side effects: ${plan.localSideEffects}`,
+        `- Items: ${plan.itemCount}`,
+        `- Appendable: ${plan.appendableCount}`,
+        `- Blocked: ${plan.blockedCount}`,
+        `- Skipped: ${plan.skippedCount}`,
+        `- Appended: ${plan.appendedCount}`,
+        "",
+        "## Quality Gates",
+        "",
+        ...plan.qualityGates.map((gate) => `- ${gate.id}: ${gate.status} - ${gate.detail}`),
+        "",
+        "## Task Work Items",
+        "",
+        "local id | kind | parent id | title | project | module | stage | status | append ready",
+        "--- | --- | --- | --- | --- | --- | --- | --- | ---",
+        ...(rows.length > 0 ? rows : [" | | | | | | | | no task items"]),
+        "",
+    ].join("\n");
+}
+function resolveStatusImportLocalSideEffects(dryRun, appendedCount, artifactUpdateCount) {
+    if (dryRun || (appendedCount === 0 && artifactUpdateCount === 0))
+        return "none";
+    if (appendedCount > 0 && artifactUpdateCount > 0)
+        return "append-work-ledger-and-update-artifacts";
+    if (appendedCount > 0)
+        return "append-work-ledger";
+    return "update-artifacts";
+}
+async function planLocalArtifactTargets(input) {
+    const references = uniqueStrings(collectIssueArtifactReferences(input.record, input.previous));
+    const targets = [];
+    const notes = [];
+    if (references.length === 0)
+        return { targets, notes: ["no explicit local artifact reference"] };
+    for (const reference of references) {
+        const artifact = artifactFileFromReference(input.target, input.config, reference);
+        if (!artifact) {
+            notes.push(`unsupported artifact reference: ${reference}`);
+            continue;
+        }
+        if (!await canReadFile(artifact.path)) {
+            notes.push(`missing local artifact: ${projectRelative(input.target, artifact.path)}`);
+            continue;
+        }
+        if (artifact.kind === "task") {
+            const content = await readFile(artifact.path, "utf8");
+            if (!input.localId || !hasTaskStatusMarker(content, input.localId)) {
+                notes.push(`task artifact lacks zsk-task-status marker for ${input.localId ?? "unknown"}: ${projectRelative(input.target, artifact.path)}`);
+                continue;
+            }
+        }
+        targets.push(projectRelative(input.target, artifact.path));
+    }
+    return { targets: uniqueStrings(targets), notes };
+}
+async function applyStatusImportArtifacts(input) {
+    let updated = 0;
+    let issueUpdated = false;
+    for (const item of input.items) {
+        if (item.blockedReasons.length > 0 || !item.localStatus)
+            continue;
+        for (const artifactTarget of item.artifactTargets) {
+            const artifactFile = resolveInsideProject(input.target, artifactTarget, "local artifact");
+            try {
+                const content = await readFile(artifactFile, "utf8");
+                const note = [
+                    `provider ${input.provider} status ${item.providerStatus}`,
+                    item.remoteId ? `remote ${item.remoteId}` : "",
+                ].filter(Boolean).join("; ");
+                const issueArtifact = isAllowedIssueArtifact(input.target, input.config, artifactFile);
+                const nextContent = issueArtifact
+                    ? updateIssueStatusBlock(content, item.localStatus, note, item.updatedAt ?? input.importedAt)
+                    : updateTaskStatusMarker(content, {
+                        localId: item.localId,
+                        localStatus: item.localStatus,
+                        provider: input.provider,
+                        providerStatus: item.providerStatus,
+                        remoteId: item.remoteId,
+                        updatedAt: item.updatedAt ?? input.importedAt,
+                    });
+                await writeFile(artifactFile, nextContent, "utf8");
+                item.updatedArtifacts.push(projectRelative(input.target, artifactFile));
+                if (issueArtifact)
+                    issueUpdated = true;
+                updated += 1;
+            }
+            catch {
+                item.artifactNotes.push(`failed to update local artifact: ${artifactTarget}`);
+            }
+        }
+    }
+    if (issueUpdated) {
+        await refreshIssueIndexes(resolve(input.target, getWorkspacePath(input.config, "issuesRoot")), resolve(input.target, getWorkspacePath(input.config, "modulesRoot")));
+    }
+    return updated;
+}
+function buildStatusImportEvents(input) {
+    return input.items
+        .filter((item) => item.blockedReasons.length === 0 && item.localId && item.localStatus)
+        .map((item) => {
+        const previous = latestWorkItem(input.existingEvents, item.localId);
+        const externalRefs = isRecord(previous?.externalRefs) ? { ...previous.externalRefs } : {};
+        if (item.remoteId)
+            externalRefs[input.provider] = item.remoteId;
+        const sourceArtifacts = uniqueStrings([
+            ...stringsOf(previous?.sourceArtifacts),
+            ...item.artifactTargets,
+            projectRelative(input.target, input.inputFile),
+        ]);
+        return {
+            event: "work.provider_status.imported",
+            version: 1,
+            occurredAt: input.importedAt,
+            producer: {
+                skill: "work",
+                stage: "import-status",
+            },
+            workItem: {
+                id: item.localId,
+                type: previous?.type ?? "task",
+                title: previous?.title ?? `Imported provider status for ${item.localId}`,
+                project: previous?.project ?? "unknown",
+                module: previous?.module ?? "unknown",
+                stage: previous?.stage ?? "import-status",
+                status: item.localStatus,
+                sourceArtifacts,
+                externalRefs,
+            },
+            status: {
+                from: previous?.status,
+                to: item.localStatus,
+                provider: input.provider,
+                providerStatus: item.providerStatus,
+                remoteId: item.remoteId,
+                observedAt: item.updatedAt ?? input.importedAt,
+                importedAt: input.importedAt,
+            },
+            links: {
+                provider: input.provider,
+                remoteId: item.remoteId,
+                inputFile: projectRelative(input.target, input.inputFile),
+            },
+            evidence: {
+                statusImportPlan: projectRelative(input.target, input.evidencePath),
+                updatedArtifacts: item.updatedArtifacts,
+            },
+        };
+    });
+}
+function collectIssueArtifactReferences(record, previous) {
+    const references = [];
+    if (record) {
+        for (const key of [
+            "issuePath",
+            "issueFile",
+            "taskPath",
+            "taskFile",
+            "artifact",
+            "artifactPath",
+            "artifactFile",
+            "localArtifact",
+            "sourceArtifact",
+            "sourceArtifacts",
+            "path",
+            "links",
+        ]) {
+            references.push(...stringsOf(record[key]));
+        }
+    }
+    references.push(...stringsOf(previous?.sourceArtifacts));
+    return references;
+}
+function artifactFileFromReference(target, config, reference) {
+    const cleaned = cleanLocalArtifactReference(reference);
+    if (!cleaned)
+        return null;
+    const resolved = resolveProjectPath(target, cleaned);
+    if (!isPathInside(target, resolved))
+        return null;
+    if (isAllowedIssueArtifact(target, config, resolved))
+        return { path: resolved, kind: "issue" };
+    if (isAllowedTaskArtifact(target, config, resolved))
+        return { path: resolved, kind: "task" };
+    const issueFile = join(resolved, "issue.md");
+    if (isAllowedIssueArtifact(target, config, issueFile))
+        return { path: issueFile, kind: "issue" };
+    return null;
+}
+function cleanLocalArtifactReference(reference) {
+    const withoutFragment = reference.trim().split("#")[0]?.split("?")[0]?.trim();
+    if (!withoutFragment)
+        return null;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(withoutFragment))
+        return null;
+    return withoutFragment;
+}
+function isAllowedIssueArtifact(target, config, issueFile) {
+    if (!toPosix(issueFile).endsWith("/issue.md"))
+        return false;
+    const issuesRoot = resolve(target, getWorkspacePath(config, "issuesRoot"));
+    if (isPathInside(issuesRoot, issueFile))
+        return true;
+    const modulesRoot = resolve(target, getWorkspacePath(config, "modulesRoot"));
+    return isPathInside(modulesRoot, issueFile) && toPosix(relative(modulesRoot, issueFile)).includes("/_issues/");
+}
+function isAllowedTaskArtifact(target, config, taskFile) {
+    if (!toPosix(taskFile).endsWith("/tasks.md"))
+        return false;
+    const modulesRoot = resolve(target, getWorkspacePath(config, "modulesRoot"));
+    const relativePath = toPosix(relative(modulesRoot, taskFile));
+    return isPathInside(modulesRoot, taskFile) && !relativePath.includes("/_issues/") && !relativePath.includes("/_evidence/");
+}
+function hasTaskStatusMarker(content, localId) {
+    return taskStatusMarkerRegex(localId).test(content);
+}
+function updateTaskStatusMarker(content, input) {
+    const marker = [
+        `<!-- zsk-task-status:start ${input.localId} -->`,
+        `- status: ${input.localStatus}`,
+        `- provider: ${input.provider}`,
+        `- provider_status: ${input.providerStatus ?? ""}`,
+        `- remote_id: ${input.remoteId ?? ""}`,
+        `- updated_at: ${input.updatedAt}`,
+        `<!-- zsk-task-status:end ${input.localId} -->`,
+    ].join("\n");
+    return content.replace(taskStatusMarkerRegex(input.localId), marker);
+}
+function taskStatusMarkerRegex(localId) {
+    const id = escapeRegExp(localId);
+    return new RegExp(`<!--\\s*zsk-task-status:start\\s+${id}\\s*-->[\\s\\S]*?<!--\\s*zsk-task-status:end\\s+${id}\\s*-->`, "m");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function canReadFile(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function latestAssignmentEvent(events, localId) {
+    for (const event of [...events].reverse()) {
+        if (event.workItem?.id === localId &&
+            (event.event === "work.assignment.requested" || event.event === "work.assignment.accepted")) {
+            return event;
+        }
+    }
+    return undefined;
+}
+function sameAssignmentEvent(event, assignment, provider) {
+    const previous = event.assignment ?? {};
+    return stringOf(previous.mode) === assignment.mode &&
+        stringOf(previous.role) === assignment.role &&
+        stringOf(previous.agent) === assignment.agent &&
+        stringOf(previous.squad) === assignment.squad &&
+        stringOf(previous.providerAgent) === assignment.providerAgent &&
+        stringOf(previous.rationale) === assignment.rationale &&
+        assignmentProviderRef(previous, provider) === (assignment.providerAgent ?? assignment.agent ?? assignment.squad);
+}
+function invertMapping(mapping) {
+    const inverted = {};
+    for (const [local, remote] of Object.entries(mapping)) {
+        if (remote)
+            inverted[remote] = local;
+    }
+    return inverted;
+}
+function resolveInsideProject(root, value, label) {
+    const resolved = resolveProjectPath(root, value);
+    if (!isPathInside(root, resolved)) {
+        console.error(pc.red(`✗ ${label} must stay inside the project: ${value}`));
+        process.exit(1);
+    }
+    return resolved;
+}
+function providerLooksConfigured(provider) {
+    const workspace = provider.workspace;
+    if (!workspace)
+        return false;
+    return !workspace.includes("<") && !workspace.includes(">");
+}
+function idOf(value) {
+    if (typeof value === "string" && value.trim())
+        return value;
+    if (isRecord(value) && typeof value.id === "string" && value.id.trim())
+        return value.id;
+    return null;
+}
+function stringOf(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function firstString(...values) {
+    for (const value of values) {
+        const candidate = stringOf(value);
+        if (candidate)
+            return candidate;
+    }
+    return null;
+}
+function numberOf(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function stringListOf(value) {
+    if (typeof value === "string" && value.trim()) {
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    if (Array.isArray(value))
+        return value.flatMap(stringListOf);
+    if (!isRecord(value))
+        return [];
+    return [
+        ...stringListOf(value.id),
+        ...stringListOf(value.name),
+        ...stringListOf(value.slug),
+        ...stringListOf(value.key),
+    ];
+}
+function normalizeExpertId(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function stringsOf(value) {
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    if (Array.isArray(value))
+        return value.flatMap(stringsOf);
+    if (!isRecord(value))
+        return [];
+    const strings = [];
+    for (const key of [
+        "path",
+        "file",
+        "issuePath",
+        "issueFile",
+        "taskPath",
+        "taskFile",
+        "artifactPath",
+        "artifactFile",
+        "localArtifact",
+        "sourceArtifact",
+        "sourceArtifacts",
+    ]) {
+        strings.push(...stringsOf(value[key]));
+    }
+    return strings;
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function compactRecord(value) {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item === null || item === undefined)
+            continue;
+        if (Array.isArray(item) && item.length === 0)
+            continue;
+        if (isRecord(item) && Object.keys(item).length === 0)
+            continue;
+        result[key] = item;
+    }
+    return result;
+}
+function projectRelative(root, value) {
+    const rel = relative(root, value);
+    return rel && !rel.startsWith("..") ? rel : value;
+}
+function toPosix(value) {
+    return value.split(/[\\/]+/).join("/");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function runId(iso) {
+    return iso.replace(/[:.]/g, "-");
+}
+//# sourceMappingURL=work.js.map