@skrr-ai/cli 0.1.22 → 0.1.24

package/dist/commands/tasks/output.js

@@ -6,200 +6,139 @@ const base_command_1 = require("../../base-command");
 const task_resolver_1 = require("../../lib/task-resolver");
 const web_url_1 = require("../../lib/web-url");
 const task_transcript_1 = require("../../lib/task-transcript");
+/** Compatibility command name. The authoritative object is Result, not output. */
 /**
- * "What did the agent produce for this task?" in one call.
+ * "awaiting review" is only true while a review can still be recorded.
  *
- * Answering that used to mean three commands and a jq hop: `tasks comments list`
- * for the canonical TASK_OUTPUT block, `tasks runs` / `execution-summary` for
- * whether the run even finished, and `tasks show --json | jq .conversationId`
- * piped into `messages list` for the agent's actual words. This command joins
- * them and states plainly when a piece is missing.
+ * A closed Task refuses one outright (`TASK_REOPEN_REQUIRED`), so printing
+ * "awaiting" described a state that could never be left — and the reader has no
+ * way to tell that from a review that is genuinely pending.
  */
+function reviewLine(review, task) {
+    if (review?.decision)
+        return review.decision;
+    const terminal = ['completed', 'cancelled'].includes(String(task?.statusType ?? ''));
+    return terminal ? 'none recorded — the Task is closed' : 'awaiting review';
+}
 class TasksOutput extends base_command_1.BaseCommand {
-    static description = 'Show a task report, verdict, and final agent reply';
-    static examples = [
-        '<%= config.bin %> tasks output <task-id>',
-        '<%= config.bin %> tasks output',
-        '<%= config.bin %> tasks output <task-id> --json',
-        '<%= config.bin %> tasks output <task-id> --full',
-    ];
+    static hidden = true;
+    static description = 'Show the current Result, Review, Deliverables, and final Run reply';
     static args = {
         id: core_1.Args.string({
-            description: 'Task ID; defaults to OVERSKY_SESSION_TASK_ID in task runtimes',
+            description: 'Task ID; defaults to the task runtime context',
             required: false,
             ignoreStdin: true,
         }),
     };
     static flags = {
-        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
-        full: core_1.Flags.boolean({
-            description: "Print the agent's final message in full instead of a 40-line preview",
-            default: false,
-        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+        task: core_1.Flags.string({ description: 'Task ID; overrides runtime context' }),
+        full: core_1.Flags.boolean({ description: 'Print the final Run message in full', default: false }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksOutput);
-        let taskIdentity;
+        let identity;
         try {
-            taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+            identity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
         }
-        catch (err) {
-            const failure = (0, task_resolver_1.taskResolutionFailure)(err);
+        catch (error) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(error);
             this.failWithCliError({
                 message: failure.message,
                 code: failure.code,
                 exit: 2,
                 retryable: false,
-                details: { suggestion: failure.suggestion, context: failure.details },
+                details: { suggestion: failure.suggestion },
             });
         }
         let task;
         try {
-            task = (await data_provider_1.dataService.getTask(taskIdentity.id, { enrich: false }));
+            task = (await data_provider_1.dataService.getTask(identity.id, { enrich: false }));
         }
-        catch (err) {
-            this.handleApiError(err);
+        catch (error) {
+            this.handleApiError(error);
         }
         const conversationId = task.conversationId ? String(task.conversationId) : null;
-        // Every source is independently optional — a task can have a verdict with no
-        // surviving run row, or a transcript with no verdict. Never let one missing
-        // surface blank the other two.
-        const [outputComment, latestRun, messages, workEvents] = await Promise.all([
-            (0, task_transcript_1.fetchLatestTaskOutputComment)(taskIdentity.id).catch(() => null),
-            (0, task_transcript_1.fetchLatestRun)(taskIdentity.id).catch(() => null),
+        const [resultBundle, resources, updates, latestRun, messages] = await Promise.all([
+            data_provider_1.dataService.listTaskResults(identity.id).catch(() => ({
+                currentResultId: null,
+                currentSpecVersion: 1,
+                results: [],
+                reviews: [],
+            })),
+            data_provider_1.dataService.listTaskResources(identity.id).catch(() => ({ data: [] })),
+            data_provider_1.dataService.listTaskUpdates(identity.id, { limit: 10 }).catch(() => ({
+                data: [],
+                nextCursor: null,
+            })),
+            (0, task_transcript_1.fetchLatestRun)(identity.id).catch(() => null),
             conversationId
                 ? (0, task_transcript_1.fetchTranscript)(conversationId).catch(() => [])
                 : Promise.resolve([]),
-            data_provider_1.dataService.listTaskWorkEvents(taskIdentity.id, { limit: 50 }).catch(() => ({ data: [] })),
         ]);
+        const result = resultBundle.results.find((item) => item.id === resultBundle.currentResultId) || null;
+        const review = result
+            ? resultBundle.reviews.find((item) => item.resultId === result.id) || null
+            : null;
         const finalMessage = (0, task_transcript_1.lastAssistantMessage)(messages);
-        const latestReportEvent = workEvents.data.find((event) => Boolean((0, data_provider_1.taskReportFromWorkEvent)(event)));
-        const latestReport = latestReportEvent ? (0, data_provider_1.taskReportFromWorkEvent)(latestReportEvent) : null;
+        const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, task);
         if (flags.json) {
             this.log(JSON.stringify({
-                object: 'sky.task_output',
-                task: {
-                    id: String(task.id ?? taskIdentity.id),
-                    identifier: task.identifier ?? null,
-                    title: task.title ?? null,
-                    status: task.status ?? null,
-                    assigneeAgentIds: task.assigneeAgentIds ?? [],
-                    conversationId,
-                    url: (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, task),
-                },
+                object: 'skrr.task_result',
+                task: { ...task, url },
+                result,
+                review,
+                deliverables: resources.data.filter((item) => item.role === 'deliverable'),
+                recentUpdates: updates.data,
                 latestRun,
-                taskReport: latestReport
-                    ? { report: latestReport, occurredAt: latestReportEvent?.occurredAt }
-                    : null,
-                taskOutput: outputComment,
-                // Present in JSON as well, so a script can detect a task closed
-                // more than once without diffing comment bodies.
-                completionCount: outputComment ? outputComment.supersededCount + 1 : 0,
                 finalMessage,
-                messageCount: messages.length,
             }, null, 2));
             return;
         }
-        this.renderHuman({
-            task: task,
-            conversationId,
-            latestRun,
-            latestReport,
-            latestReportAt: latestReportEvent?.occurredAt ? String(latestReportEvent.occurredAt) : null,
-            outputComment,
-            finalMessage,
-            full: flags.full,
-        });
-    }
-    renderHuman({ task, conversationId, latestRun, latestReport, latestReportAt, outputComment, finalMessage, full, }) {
-        const ref = String(task.identifier ?? task.id ?? '-');
-        const agents = Array.isArray(task.assigneeAgentIds) ? task.assigneeAgentIds : [];
-        this.log(`Task:     ${ref} — ${task.title ?? '-'}`);
-        this.log(`Status:   ${task.status ?? '-'}`);
-        this.log(`Agent:    ${agents.length > 0 ? agents.join(', ') : '-'}`);
-        this.log(`Last run: ${latestRun
-            ? `${latestRun.status} (${(0, task_transcript_1.formatTime)(latestRun.startedAt)}${latestRun.durationMs != null ? `, ${latestRun.durationMs}ms` : ''})`
-            : 'never executed'}`);
+        this.log(`Task:    ${task.identifier ?? task.id} — ${task.title ?? '-'}`);
+        this.log(`Status:  ${task.status ?? '-'}`);
+        this.log(`Run:     ${latestRun ? `${latestRun.status} · ${(0, task_transcript_1.formatTime)(latestRun.startedAt)}` : 'none'}`);
         this.log('');
-        if (latestReport) {
-            // Timestamped like the Verdict below it. These two blocks are selected
-            // independently — the newest task-report work event and the newest
-            // TASK_OUTPUT comment — so on a task completed more than once they can
-            // come from different completions and disagree. Undated, that was
-            // invisible.
-            const reportAt = latestReportAt ? ` · ${(0, task_transcript_1.formatTime)(latestReportAt)}` : '';
-            this.log(`Outcome (task report${reportAt}):`);
-            this.log(`  ${latestReport.outcome}`);
-            this.log('  findings:');
-            for (const finding of latestReport.findings)
-                this.log(`    - ${finding}`);
-            if (latestReport.evidence.length > 0) {
-                this.log('  evidence:');
-                for (const evidence of latestReport.evidence)
-                    this.log(`    - ${evidence}`);
-            }
-            if (latestReport.nextActions.length > 0) {
-                this.log('  next actions:');
-                for (const next of latestReport.nextActions)
-                    this.log(`    - ${next}`);
+        if (result) {
+            this.log(`Result v${result.version} · ${(0, task_transcript_1.formatTime)(result.submittedAt)}`);
+            this.log(`  ${result.summary}`);
+            if (result.conclusion) {
+                this.log(`  conclusion (${result.conclusion.type}): ${JSON.stringify(result.conclusion.value)}`);
             }
-            this.log('');
+            this.log(`Review:  ${reviewLine(review, task)}`);
+            if (review?.rationale)
+                this.log(`  ${review.rationale}`);
         }
-        if (outputComment) {
-            const { parsed } = outputComment;
-            this.log(`Verdict (TASK_OUTPUT · ${(0, task_transcript_1.formatTime)(outputComment.createdAt)}):`);
-            this.log(`  status:    ${parsed.status || '-'}`);
-            this.log(`  verdict:   ${parsed.verdict || '-'}`);
-            this.log(`  artifacts: ${parsed.artifacts || '-'}`);
-            if (parsed.summary) {
-                this.log('  summary:');
-                for (const line of parsed.summary.split('\n'))
-                    this.log(`    ${line}`);
-            }
-            // The field parser is single-line per field (see task-transcript.ts). If the
-            // block carried anything else, say so rather than presenting a partial verdict.
-            if (outputComment.unattributed.length > 0) {
-                this.log(`  (+${outputComment.unattributed.length} unparsed block line(s) — see \`skrr tasks comments list\`)`);
-            }
-            // Reconcile the three signals a parked run shows — `completed`,
-            // `UNVERIFIED`, and `Last run: failed` — which otherwise read as a
-            // contradiction. (OSK-4945)
-            if (outputComment.supersededCount > 0) {
-                // `tasks complete` succeeds on an already-done task and posts another
-                // block, so the canonical-looking screen can be assembled from several
-                // closeouts. Say so rather than presenting it as one record.
-                const total = outputComment.supersededCount + 1;
-                const earlier = outputComment.supersededCount === 1 ? 'block' : 'blocks';
-                this.log(`  note:      completed ${total} times — ${outputComment.supersededCount} earlier TASK_OUTPUT ${earlier} exist.`);
-                this.log('             The Outcome above may come from a different completion than this');
-                this.log('             Verdict. `skrr tasks comments list` shows every one.');
-            }
-            const note = (0, task_transcript_1.unverifiedOutcomeNote)(parsed.verdict);
-            if (note)
-                this.log(`  note:      ${note}`);
+        else if (task.specVersion === undefined) {
+            // A Task predating the canonical model has no TaskResult row and never
+            // will. "none submitted" reads as "the work was never reported", which
+            // for a completed legacy Task is the opposite of the truth.
+            this.log('Result:  not recorded under the canonical model (this Task predates it)');
+            this.log('         its closeout is in `skrr tasks comments list` / `tasks transcript`');
         }
         else {
-            this.log('Verdict:  no TASK_OUTPUT comment posted yet.');
+            this.log('Result:  none submitted');
         }
+        const deliverables = resources.data.filter((item) => item.role === 'deliverable');
         this.log('');
+        this.log(`Deliverables: ${deliverables.length}`);
+        for (const item of deliverables) {
+            this.log(`  ${item.title || item.identity || item.kind} · ${item.location || 'no locator'} · ${item.status}/${item.evidenceLevel}`);
+        }
         if (finalMessage) {
             const lines = (finalMessage.text || '(empty message)').split('\n');
-            const preview = full ? lines : lines.slice(0, 40);
-            this.log(`Final agent message (${finalMessage.sender} · ${(0, task_transcript_1.formatTime)(finalMessage.createdAt)}):`);
+            const preview = flags.full ? lines : lines.slice(0, 40);
+            this.log('');
+            this.log(`Final Run reply (${(0, task_transcript_1.formatTime)(finalMessage.createdAt)}):`);
             for (const line of preview)
                 this.log(`  ${line}`);
-            if (preview.length < lines.length) {
-                this.log('');
-                this.log(`  … ${lines.length - preview.length} more line(s). Use --full, or \`skrr tasks transcript ${task.id ?? ref}\`.`);
-            }
+            if (preview.length < lines.length)
+                this.log(`  … ${lines.length - preview.length} more line(s)`);
         }
-        else if (conversationId) {
-            this.log('Final agent message: none yet in the execution conversation.');
-        }
-        else {
-            this.log('Final agent message: task has no execution conversation yet.');
+        if (url) {
+            this.log('');
+            this.log(`Task: ${url}#task-result`);
         }
     }
 }

package/dist/commands/tasks/report.d.ts

@@ -1,10 +1,9 @@
 import { BaseCommand } from '../../base-command';
 /**
- * Record a concise, self-contained decision record in the task work ledger.
- * It deliberately does not finish the task: reports can be checkpoints,
- * proposals, or the handoff immediately before `tasks complete`.
+ * Compatibility spelling for submitting a versioned Task Result.
  */
 export default class TasksReport extends BaseCommand {
+    static hidden: boolean;
     static description: string;
     static examples: string[];
     static args: {
@@ -19,6 +18,7 @@ export default class TasksReport extends BaseCommand {
         evidence: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         next: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         deliverable: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        artifact: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/tasks/report.js

@@ -3,23 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
-const api_fetch_1 = require("../../lib/api-fetch");
 const outbox_1 = require("../../lib/outbox");
 const task_report_1 = require("../../lib/task-report");
 const task_resolver_1 = require("../../lib/task-resolver");
 const tasks_1 = require("../../lib/tasks");
-const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
+const task_artifact_flags_1 = require("../../lib/task-artifact-flags");
 const web_url_1 = require("../../lib/web-url");
 /**
- * Record a concise, self-contained decision record in the task work ledger.
- * It deliberately does not finish the task: reports can be checkpoints,
- * proposals, or the handoff immediately before `tasks complete`.
+ * Compatibility spelling for submitting a versioned Task Result.
  */
 class TasksReport extends base_command_1.BaseCommand {
-    static description = 'Record a self-contained outcome, findings, evidence, and next actions';
+    static hidden = true;
+    static description = 'DEPRECATED compatibility spelling for `tasks result submit`. Every call submits a ' +
+        'versioned Result; `--kind` is ignored. Use `tasks result submit` (submit only) or ' +
+        '`tasks complete` (submit and close).';
     static examples = [
-        '<%= config.bin %> tasks report <task-id> --outcome "Adopt the event ledger" --finding "The task page omits work-event details" --evidence "Task detail reads only legacy activity" --next "Add an Outcome section"',
-        '<%= config.bin %> tasks report <task-id> --kind handoff --outcome "Ready for review" --finding "All acceptance criteria are met" --deliverable "src/task.ts" --json',
+        '<%= config.bin %> tasks report <task-id> --outcome "Adopt the event ledger" --finding "The task page omits work-event details" --evidence "Task detail reads only legacy activity" --next "Add a Result section"',
+        '<%= config.bin %> tasks report <task-id> --kind handoff --outcome "Ready for review" --finding "All expectations are met" --deliverable "file:src/task.ts" --json',
     ];
     static args = {
         id: core_1.Args.string({
@@ -32,7 +32,7 @@ class TasksReport extends base_command_1.BaseCommand {
         task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         kind: core_1.Flags.string({
-            description: 'Whether this is a decision or a handoff',
+            description: 'Deprecated compatibility option; every report is now a Result submission',
             options: ['decision', 'handoff'],
             default: 'decision',
         }),
@@ -53,6 +53,10 @@ class TasksReport extends base_command_1.BaseCommand {
             description: 'Durable file, commit, PR, or URL (repeatable)',
             multiple: true,
         }),
+        artifact: core_1.Flags.string({
+            description: 'Compatibility alias for --deliverable used by older managed instruction blocks',
+            multiple: true,
+        }),
     };
     async run() {
         this.requireAuth();
@@ -88,56 +92,77 @@ class TasksReport extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
-        const kind = flags.kind;
-        const event = {
-            idempotencyKey: (0, outbox_1.idempotencyKeyFor)('task-report', task.id, JSON.stringify({ report, kind: flags.kind })),
-            kind,
-            ...(0, task_report_1.taskReportEventFields)(report),
-            artifacts: flags.deliverable?.map((ref) => ({ label: 'deliverable', ref })),
-        };
-        // THE SAME BRIDGE `tasks complete` CARRIES, for the same reason.
-        //
-        // `--deliverable` here is prose for a work event's `artifacts` list, and
-        // the ledger the completion gate reads is written by `tasks deliverable
-        // add`. Three commands in this CLI answer to the word and only one of them
-        // writes the ledger — and the project's own operating instructions teach
-        // this spelling. So a value that is unambiguously a coordinate is forwarded
-        // to the ledger too; prose is left exactly as it was, because guessing a
-        // coordinate out of prose fills the ledger with rows nobody can look up.
-        for (const ref of flags.deliverable ?? []) {
+        const deliverables = (0, task_artifact_flags_1.mergeTaskArtifactFlags)(flags.deliverable, flags.artifact);
+        const resourceLinkIds = [];
+        for (const ref of deliverables) {
             const parsed = (0, tasks_1.parseDeliverableCoordinate)(ref);
             if (!parsed.ok) {
+                this.failWithCliError({
+                    message: parsed.error,
+                    code: 'INVALID_DELIVERABLE_COORDINATE',
+                    exit: 1,
+                    retryable: false,
+                    details: { deliverable: ref },
+                });
                 continue;
             }
             try {
-                await data_provider_1.dataService.addTaskDeliverable(task.id, parsed.value);
+                const recorded = await data_provider_1.dataService.addTaskDeliverable(task.id, {
+                    ...parsed.value,
+                    idempotencyKey: (0, outbox_1.idempotencyKeyFor)('task-deliverable', task.id, ref),
+                });
+                resourceLinkIds.push(recorded.link.id);
             }
-            catch {
-                // Best-effort: a report must still be posted when the ledger write
-                // fails, and the completion gate's refusal names the command that
-                // writes it.
+            catch (error) {
+                this.handleApiError(error);
             }
         }
-        const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('event');
+        const payload = {
+            summary: report.outcome,
+            body: [
+                report.findings.length
+                    ? `Findings\n${report.findings.map((item) => `- ${item}`).join('\n')}`
+                    : '',
+                report.evidence.length
+                    ? `Evidence\n${report.evidence.map((item) => `- ${item}`).join('\n')}`
+                    : '',
+                report.nextActions.length
+                    ? `Next\n${report.nextActions.map((item) => `- ${item}`).join('\n')}`
+                    : '',
+            ]
+                .filter(Boolean)
+                .join('\n\n'),
+            structuredContent: {
+                schema: 'skrr.task-report/v1',
+                value: {
+                    findings: report.findings,
+                    evidence: report.evidence,
+                    nextActions: report.nextActions,
+                },
+            },
+            resourceLinkIds,
+            remainingWork: [],
+        };
         let result;
         try {
-            result = sessionPath
-                ? await (0, api_fetch_1.apiFetch)(sessionPath, { method: 'POST', body: event })
-                : await data_provider_1.dataService.appendTaskWorkEvent({ taskId: task.id, data: event });
+            result = await data_provider_1.dataService.submitTaskResult({
+                taskId: task.id,
+                data: {
+                    ...payload,
+                    idempotencyKey: (0, outbox_1.idempotencyKeyFor)('task-result', task.id, JSON.stringify(payload)),
+                },
+            });
         }
         catch (error) {
             this.handleApiError(error);
         }
-        if (sessionPath && result && typeof result === 'object' && 'entry' in result) {
-            result = result.entry;
-        }
         const taskUrl = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: task.id });
-        const url = taskUrl ? `${taskUrl}#task-outcome` : null;
+        const url = taskUrl ? `${taskUrl}#task-result` : null;
         if (flags.json) {
-            this.log(JSON.stringify({ entry: result, url }, null, 2));
+            this.log(JSON.stringify({ ...result, url }, null, 2));
             return;
         }
-        this.log(`Recorded ${kind} report on task ${task.id}.${url ? ` ${url}` : ''}`);
+        this.log(`Submitted Result v${result.result.version} on task ${task.id}.${url ? ` ${url}` : ''}`);
     }
 }
 exports.default = TasksReport;

package/dist/commands/tasks/resource/add.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksResourceAdd extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        role: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        coordinate: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        provider: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'content-digest': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        expectation: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'result-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'run-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'idempotency-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/resource/add.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const outbox_1 = require("../../../lib/outbox");
+const tasks_1 = require("../../../lib/tasks");
+const RESOURCE_ROLES = ['input', 'reference', 'evidence', 'attachment', 'deliverable'];
+class TasksResourceAdd extends base_command_1.BaseCommand {
+    static description = 'Link an exact input, reference, evidence item, attachment, or deliverable to a task';
+    static examples = [
+        '<%= config.bin %> tasks resource add <task-id> input file/pdf:brief@Drive/Briefs',
+        '<%= config.bin %> tasks resource add <task-id> evidence code:a1b2c3d@origin/main --provider github',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+        role: core_1.Args.string({
+            description: 'How the resource relates to this task',
+            required: true,
+            options: [...RESOURCE_ROLES],
+            ignoreStdin: true,
+        }),
+        coordinate: core_1.Args.string({
+            description: '<kind>[/<format>]:<identity>[@<location>]',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        status: core_1.Flags.string({
+            options: ['unknown', 'local', 'in_review', 'available', 'unavailable', 'superseded'],
+            description: 'Observed availability. Evidence strength is recorded separately.',
+        }),
+        title: core_1.Flags.string({ description: 'Human-readable Resource name' }),
+        provider: core_1.Flags.string({ description: 'Provider, such as github or drive' }),
+        version: core_1.Flags.string({ description: 'Exact provider version, such as a full commit SHA' }),
+        'content-digest': core_1.Flags.string({ description: 'Integrity digest for this exact version' }),
+        expectation: core_1.Flags.string({ multiple: true, description: 'Expectation id this supports' }),
+        'result-id': core_1.Flags.string({ description: 'Result version this Resource supports' }),
+        'run-id': core_1.Flags.string({ description: 'Run that produced or observed it' }),
+        'idempotency-key': core_1.Flags.string({ description: 'Stable retry key' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksResourceAdd);
+        const parsed = (0, tasks_1.parseDeliverableCoordinate)(args.coordinate);
+        if (!parsed.ok)
+            this.error(parsed.error, { exit: 1 });
+        const payload = {
+            ...parsed.value,
+            role: args.role,
+            status: flags.status,
+            title: flags.title,
+            provider: flags.provider,
+            version: flags.version,
+            contentDigest: flags['content-digest'],
+            expectationIds: flags.expectation,
+            resultId: flags['result-id'],
+            runId: flags['run-id'],
+            idempotencyKey: flags['idempotency-key'] ||
+                (0, outbox_1.idempotencyKeyFor)('task-resource', args.task, JSON.stringify({ role: args.role, coordinate: parsed.value, status: flags.status })),
+        };
+        let result;
+        try {
+            result = await data_provider_1.dataService.recordTaskResource(args.task, payload);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        this.log(`Linked ${args.role} Resource ${result.link.id}: ${parsed.value.kind}:${parsed.value.identity}`);
+    }
+}
+exports.default = TasksResourceAdd;

package/dist/commands/tasks/resource/list.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksResourceList extends BaseCommand {
+    static description: string;
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        role: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/resource/list.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const task_resolver_1 = require("../../../lib/task-resolver");
+const RESOURCE_ROLES = ['input', 'reference', 'evidence', 'attachment', 'deliverable'];
+class TasksResourceList extends base_command_1.BaseCommand {
+    static description = 'List the exact Resources linked to a task, including their role and evidence state';
+    static args = {
+        task: core_1.Args.string({ required: false, ignoreStdin: true, description: 'Task id or ref' }),
+    };
+    static flags = {
+        task: core_1.Flags.string({ description: 'Task id; overrides runtime context' }),
+        role: core_1.Flags.string({ options: [...RESOURCE_ROLES], description: 'Only show one Task role' }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksResourceList);
+        const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.task, flagTask: flags.task });
+        let result;
+        try {
+            result = await data_provider_1.dataService.listTaskResources(task.id, {
+                role: flags.role,
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        if (!result.data.length)
+            return this.log('No Resources linked.');
+        for (const item of result.data) {
+            this.log(`${item.linkId} · ${item.role} · ${item.title || item.identity || item.kind}\n` +
+                `  ${item.location || 'no locator'} · ${item.versionFidelity} · ${item.status} · ${item.evidenceLevel}`);
+        }
+    }
+}
+exports.default = TasksResourceList;

package/dist/commands/tasks/result/show.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksResultShow extends BaseCommand {
+    static description: string;
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        history: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}