orizu 0.5.7 → 0.5.9

package/dist/report-comments-cli.js

@@ -0,0 +1,325 @@
+const COMMENTS_TARGET_USAGE = 'Use exactly one of --prompt <id-or-name>, --run <run-id>, or --task <task-id>';
+function reportCommentsUsage(action) {
+    const target = '(--prompt <id-or-name> --project <team/project> [--label <label> | --version <id>] | --run <run-id> | --task <task-id>)';
+    if (action === 'list') {
+        return `Usage: orizu comments list ${target} [--json]`;
+    }
+    if (action === 'add') {
+        return `Usage: orizu comments add ${target} --body <text|@file> [--anchor <text>] [--lines <start:end>] [--via <name>] [--json]`;
+    }
+    if (action === 'reply') {
+        return 'Usage: orizu comments reply <comment-id> --body <text|@file> [--via <name>] [--json]';
+    }
+    if (action === 'edit') {
+        return 'Usage: orizu comments edit <comment-id> --body <text|@file> [--json]';
+    }
+    return `Usage: orizu comments ${action} <comment-id> [--json]`;
+}
+function compactTerminalText(ctx, value, maxLength = 160) {
+    const compact = ctx.sanitizeTerminalText(value).replace(/\s+/g, ' ').trim();
+    if (compact.length <= maxLength) {
+        return compact;
+    }
+    return `${compact.slice(0, Math.max(0, maxLength - 1)).trim()}…`;
+}
+async function readReportCommentError(ctx, response) {
+    const status = response.status
+        ? `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ''}`
+        : 'request failed';
+    const contentType = response.headers.get('content-type') || '';
+    if (!contentType.toLowerCase().includes('application/json')) {
+        return status;
+    }
+    try {
+        const parsed = await response.clone().json();
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const error = parsed.error;
+            if (typeof error === 'string' && error.trim()) {
+                return compactTerminalText(ctx, error, 220);
+            }
+        }
+    }
+    catch {
+        // Fall through to the status-only message for malformed JSON errors.
+    }
+    return status;
+}
+function printIndentedBody(ctx, value, indent) {
+    const lines = ctx.sanitizeTerminalText(value || '').split(/\r?\n/);
+    for (const line of lines) {
+        ctx.printLine(`${indent}${line}`);
+    }
+}
+function formatReportCommentAnchor(ctx, anchor) {
+    if (!anchor) {
+        return null;
+    }
+    const lineLabel = anchor.startLine && anchor.endLine
+        ? anchor.startLine === anchor.endLine
+            ? `line ${anchor.startLine}`
+            : `lines ${anchor.startLine}-${anchor.endLine}`
+        : null;
+    const selectedText = anchor.text ? `"${compactTerminalText(ctx, anchor.text, 180)}"` : null;
+    if (lineLabel && selectedText) {
+        return `${lineLabel}: ${selectedText}`;
+    }
+    return lineLabel || selectedText;
+}
+function reportCommentAuthorName(author) {
+    const personName = author?.person?.name;
+    const name = personName || author?.name || 'Unknown';
+    const via = author?.via ? ` via ${author.via}` : '';
+    const agent = author?.actor === 'agent'
+        ? author.onBehalfOf
+            ? ` (agent on behalf of ${author.onBehalfOf})`
+            : ' (agent)'
+        : '';
+    return `${name}${via}${agent}`;
+}
+function printReportCommentSubject(ctx, data) {
+    if (data.prompt && data.version) {
+        const versionLabel = data.version.versionLabel || (data.version.versionNumber ? `v${data.version.versionNumber}` : data.version.id);
+        ctx.printLine(`Prompt: ${ctx.sanitizeTerminalText(data.prompt.name)} (${ctx.sanitizeTerminalText(data.prompt.id)})`);
+        ctx.printLine(`Version: ${ctx.sanitizeTerminalText(String(versionLabel))} (${ctx.sanitizeTerminalText(data.version.id)})`);
+        return;
+    }
+    if (data.run) {
+        ctx.printLine(`Optimization run: ${ctx.sanitizeTerminalText(data.run.id)}`);
+        return;
+    }
+    if (data.task) {
+        const title = data.task.title ? `${ctx.sanitizeTerminalText(data.task.title)} ` : '';
+        ctx.printLine(`Task: ${title}(${ctx.sanitizeTerminalText(data.task.id)})`);
+        return;
+    }
+    if (data.subject) {
+        ctx.printLine(`Subject: ${ctx.sanitizeTerminalText(data.subject.type)} ${ctx.sanitizeTerminalText(data.subject.id)}`);
+    }
+}
+function printReportComments(ctx, data) {
+    printReportCommentSubject(ctx, data);
+    ctx.printLine(`Comments: ${data.summary.threadCount} thread${data.summary.threadCount === 1 ? '' : 's'} ` +
+        `(${data.summary.openThreadCount} open, ${data.summary.resolvedThreadCount} resolved, ${data.summary.replyCount} replies)`);
+    if (data.comments.length === 0) {
+        ctx.printLine('\nNo comments found for this report.');
+        return;
+    }
+    for (const [index, thread] of data.comments.entries()) {
+        const authorName = reportCommentAuthorName(thread.author);
+        const anchor = formatReportCommentAnchor(ctx, thread.anchor);
+        ctx.printLine('');
+        ctx.printLine(`${index + 1}. [${thread.status}] ${ctx.sanitizeTerminalText(thread.id)} · ` +
+            `${ctx.sanitizeTerminalText(authorName)} · ${ctx.sanitizeTerminalText(thread.createdAt)}`);
+        if (thread.editedAt) {
+            ctx.printLine(`   Edited: ${ctx.sanitizeTerminalText(thread.editedAt)}`);
+        }
+        if (anchor) {
+            ctx.printLine(`   Selection: ${anchor}`);
+        }
+        printIndentedBody(ctx, thread.body, '   ');
+        if (thread.replies.length > 0) {
+            ctx.printLine(`   Replies (${thread.replies.length})`);
+            for (const reply of thread.replies) {
+                const replyAuthor = reportCommentAuthorName(reply.author);
+                ctx.printLine(`   - ${ctx.sanitizeTerminalText(reply.id)} · ` +
+                    `${ctx.sanitizeTerminalText(replyAuthor)} · ${ctx.sanitizeTerminalText(reply.createdAt)}`);
+                if (reply.editedAt) {
+                    ctx.printLine(`     Edited: ${ctx.sanitizeTerminalText(reply.editedAt)}`);
+                }
+                printIndentedBody(ctx, reply.body, '     ');
+            }
+        }
+    }
+}
+async function reportCommentsTargetParams(ctx, action) {
+    const promptRef = ctx.getArg('--prompt');
+    const runId = ctx.getArg('--run') || ctx.getArg('--run-id');
+    const taskId = ctx.getArg('--task');
+    ctx.rejectDashPrefixedOptionValue('--prompt', promptRef);
+    ctx.rejectDashPrefixedOptionValue('--run', runId);
+    ctx.rejectDashPrefixedOptionValue('--task', taskId);
+    const present = [
+        promptRef ? 'prompt' : null,
+        runId ? 'run' : null,
+        taskId ? 'task' : null,
+    ].filter(Boolean);
+    if (present.length !== 1) {
+        throw new Error(`${reportCommentsUsage(action)}\n${COMMENTS_TARGET_USAGE}`);
+    }
+    const params = new URLSearchParams();
+    if (promptRef) {
+        const project = ctx.getArg('--project') || await ctx.resolveProjectSlug(null);
+        const label = ctx.getArg('--label');
+        const version = ctx.getArg('--version');
+        ctx.rejectDashPrefixedOptionValue('--project', project);
+        ctx.rejectDashPrefixedOptionValue('--label', label);
+        ctx.rejectDashPrefixedOptionValue('--version', version);
+        if (label && version) {
+            throw new Error('Use either --label or --version, not both');
+        }
+        params.set('prompt', promptRef);
+        params.set('project', project);
+        if (label)
+            params.set('label', label);
+        if (version)
+            params.set('version', version);
+        return params;
+    }
+    if (runId) {
+        params.set('run', runId);
+        return params;
+    }
+    params.set('task', taskId);
+    return params;
+}
+function readReportCommentBodyInput(ctx, action) {
+    const body = ctx.getArg('--body');
+    ctx.rejectDashPrefixedOptionValue('--body', body);
+    if (!body) {
+        throw new Error(reportCommentsUsage(action));
+    }
+    if (body === '@') {
+        throw new Error('Usage: --body <text|@file>');
+    }
+    const value = body.startsWith('@') ? ctx.readSourceFile(body.slice(1)) : body;
+    if (!value.trim()) {
+        throw new Error('Comment body must not be blank');
+    }
+    return value;
+}
+function readReportCommentAnchorInput(ctx) {
+    const anchor = ctx.getArg('--anchor');
+    const lines = ctx.getArg('--lines');
+    ctx.rejectDashPrefixedOptionValue('--anchor', anchor);
+    ctx.rejectDashPrefixedOptionValue('--lines', lines);
+    let startLine = null;
+    let endLine = null;
+    if (lines) {
+        const match = lines.match(/^(\d+):(\d+)$/);
+        if (!match) {
+            throw new Error('--lines must use format <start:end>');
+        }
+        startLine = Number(match[1]);
+        endLine = Number(match[2]);
+        if (!Number.isInteger(startLine) || !Number.isInteger(endLine) || startLine < 1 || endLine < startLine) {
+            throw new Error('--lines must contain positive integers where end is greater than or equal to start');
+        }
+    }
+    if (!anchor && startLine === null) {
+        return null;
+    }
+    return {
+        text: anchor ? anchor.trim() : null,
+        startLine,
+        endLine,
+    };
+}
+function readReportCommentViaInput(ctx) {
+    const via = ctx.getArg('--via');
+    ctx.rejectDashPrefixedOptionValue('--via', via);
+    return via?.trim() || undefined;
+}
+async function listReportComments(ctx) {
+    const params = await reportCommentsTargetParams(ctx, 'list');
+    const response = await ctx.authedFetch(`/api/cli/report-comments?${params.toString()}`);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch report comments: ${await readReportCommentError(ctx, response)}`);
+    }
+    const data = await ctx.parseJsonResponse(response, 'Report comments');
+    if (ctx.hasJsonFlag()) {
+        ctx.printJson(data);
+        return;
+    }
+    printReportComments(ctx, data);
+}
+async function addReportComment(ctx) {
+    const params = await reportCommentsTargetParams(ctx, 'add');
+    const body = readReportCommentBodyInput(ctx, 'add');
+    const response = await ctx.authedFetch(`/api/cli/report-comments?${params.toString()}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            body,
+            via: readReportCommentViaInput(ctx),
+            anchor: readReportCommentAnchorInput(ctx),
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to add report comment: ${await readReportCommentError(ctx, response)}`);
+    }
+    const data = await ctx.parseJsonResponse(response, 'Report comment add');
+    if (ctx.hasJsonFlag()) {
+        ctx.printJson(data);
+        return;
+    }
+    ctx.printLine(`Added comment ${ctx.sanitizeTerminalText(data.comment.id)}`);
+}
+async function replyReportComment(ctx) {
+    const commentId = ctx.getPositionalArg(2);
+    if (!commentId) {
+        throw new Error(reportCommentsUsage('reply'));
+    }
+    const response = await ctx.authedFetch(`/api/cli/report-comments/${encodeURIComponent(commentId)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            body: readReportCommentBodyInput(ctx, 'reply'),
+            via: readReportCommentViaInput(ctx),
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to reply to report comment: ${await readReportCommentError(ctx, response)}`);
+    }
+    const data = await ctx.parseJsonResponse(response, 'Report comment reply');
+    if (ctx.hasJsonFlag()) {
+        ctx.printJson(data);
+        return;
+    }
+    ctx.printLine(`Added reply ${ctx.sanitizeTerminalText(data.comment.id)} to ${ctx.sanitizeTerminalText(commentId)}`);
+}
+async function updateReportComment(ctx, action) {
+    const commentId = ctx.getPositionalArg(2);
+    if (!commentId) {
+        throw new Error(reportCommentsUsage(action));
+    }
+    const payload = action === 'edit'
+        ? { body: readReportCommentBodyInput(ctx, 'edit') }
+        : { resolved: action === 'resolve' };
+    const response = await ctx.authedFetch(`/api/cli/report-comments/${encodeURIComponent(commentId)}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to ${action} report comment: ${await readReportCommentError(ctx, response)}`);
+    }
+    const data = await ctx.parseJsonResponse(response, `Report comment ${action}`);
+    if (ctx.hasJsonFlag()) {
+        ctx.printJson(data);
+        return;
+    }
+    const verb = action === 'unresolve' ? 'Reopened' : action === 'edit' ? 'Edited' : 'Resolved';
+    ctx.printLine(`${verb} comment ${ctx.sanitizeTerminalText(data.comment.id)}`);
+}
+export async function reportCommentsCommand(action, ctx) {
+    if (action === 'list') {
+        await listReportComments(ctx);
+        return;
+    }
+    if (action === 'add') {
+        await addReportComment(ctx);
+        return;
+    }
+    if (action === 'reply') {
+        await replyReportComment(ctx);
+        return;
+    }
+    if (action === 'resolve' || action === 'unresolve' || action === 'edit') {
+        await updateReportComment(ctx, action);
+        return;
+    }
+    throw new Error('Usage: orizu comments <list|add|reply|resolve|unresolve|edit> ...');
+}
+export function throwDeprecatedPromptCommentsCommand() {
+    throw new Error('orizu prompts comments has moved. Use `orizu comments list --prompt <prompt-id-or-name> --project <team/project> [--label <label> | --version <id>]`.');
+}

package/dist/skill-installer.js

@@ -14,14 +14,17 @@ export const SKILL_INSTALL_TARGETS = [
     'codex-project',
     'claude-user',
     'claude-project',
+    'opencode-user',
+    'opencode-project',
     'agents-md',
 ];
 export const SKILL_META_FILENAME = '.orizu-skill-meta.json';
-export const SKILL_INSTALL_AGENTS = ['claude', 'codex'];
+export const SKILL_INSTALL_AGENTS = ['claude', 'codex', 'opencode'];
 const PROJECT_LEVEL_TARGETS = [
     'agents-project',
     'codex-project',
     'claude-project',
+    'opencode-project',
 ];
 function getCliRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), '..');
@@ -134,12 +137,24 @@ export function getSkillInstallPath(target, options) {
     if (target === 'claude-project') {
         return resolve(cwd, '.claude', 'skills', SKILL_NAME);
     }
+    // OpenCode discovers user skills under XDG config (~/.config/opencode/skills)
+    // and project skills under .opencode/skills (ALI-1044). The copy/link machinery
+    // is agent-neutral; only the destination path differs.
+    if (target === 'opencode-user') {
+        return resolve(home, '.config', 'opencode', 'skills', SKILL_NAME);
+    }
+    if (target === 'opencode-project') {
+        return resolve(cwd, '.opencode', 'skills', SKILL_NAME);
+    }
     return resolve(cwd, 'AGENTS.md');
 }
 export function getTargetForAgent(agent, scope) {
     if (agent === 'claude') {
         return scope === 'global' ? 'claude-user' : 'claude-project';
     }
+    if (agent === 'opencode') {
+        return scope === 'global' ? 'opencode-user' : 'opencode-project';
+    }
     return scope === 'global' ? 'codex-user' : 'agents-project';
 }
 export function isSkillInstallAgent(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orizu",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "private": false,
   "type": "module",
   "bin": {

package/src/credentials.ts

@@ -210,6 +210,52 @@ export function getActiveBaseUrl(): string | null {
   return config?.activeBaseUrl || null
 }
 
+/**
+ * In-sandbox bearer resolution (ALI-1044). Resolves a bearer supplied out-of-band
+ * to the hosted agent, WITHOUT consulting credentials.json:
+ *   1. `ORIZU_TOKEN` — an explicit bearer in the environment (wins if present).
+ *   2. `ORIZU_TOKEN_FILE` — an absolute path to a 0600 file whose TRIMMED contents
+ *      are the bearer.
+ * Returns null when neither is set, so callers fall through to credentials.json.
+ *
+ * The token file is read FRESH on EVERY call and never cached: the hosted loop
+ * ROTATES the file underneath a long-lived agent process, so caching the value
+ * would pin a stale (soon-expired) bearer. The token is never logged, echoed, or
+ * passed via argv — only returned to the caller for a single request's header.
+ *
+ * A set-but-unreadable/empty `ORIZU_TOKEN_FILE` throws a clear error rather than
+ * returning null, so a misconfigured sandbox fails loudly instead of silently
+ * falling back to (absent) credentials.json and emitting a confusing "not logged
+ * in" message.
+ */
+export function resolveEnvBearerToken(): string | null {
+  const explicit = process.env.ORIZU_TOKEN
+  if (explicit && explicit.trim()) {
+    return explicit.trim()
+  }
+
+  const tokenFile = process.env.ORIZU_TOKEN_FILE
+  if (tokenFile && tokenFile.length > 0) {
+    if (!existsSync(tokenFile)) {
+      throw new Error(`ORIZU_TOKEN_FILE is set to ${tokenFile} but no such file exists.`)
+    }
+    let raw: string
+    try {
+      raw = readFileSync(tokenFile, 'utf8')
+    } catch (error) {
+      const detail = isNodeError(error) ? error.message : String(error)
+      throw new Error(`Failed to read ORIZU_TOKEN_FILE (${tokenFile}): ${detail}`)
+    }
+    const token = raw.trim()
+    if (!token) {
+      throw new Error(`ORIZU_TOKEN_FILE (${tokenFile}) is empty.`)
+    }
+    return token
+  }
+
+  return null
+}
+
 export function setActiveBaseUrl(baseUrl: string | null) {
   const config = loadCredentialsConfigForWrite()
   config.activeBaseUrl = baseUrl

package/src/help.ts

@@ -35,6 +35,7 @@ const GROUPS: CliGroupDoc[] = [
   { name: 'Teams', summary: 'Manage teams and team memberships.' },
   { name: 'Projects', summary: 'Manage projects inside teams.' },
   { name: 'Prompts and judges', summary: 'Work with versioned prompt and judge artifacts.' },
+  { name: 'Report comments', summary: 'Review and mutate anchored report comments across prompt, optimization, and task reports.' },
   { name: 'Scorers and runners', summary: 'Register scorers, push runnable artifacts, execute runners, and submit scores.' },
   { name: 'Optimizations', summary: 'Start, run, export, and finalize optimization runs.' },
   { name: 'Apps', summary: 'Create, preview, update, inspect, and export review apps.' },
@@ -82,6 +83,67 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
     summary: 'Submit an optimization event payload.',
     group: 'Optimizations',
   },
+  {
+    path: ['comments', 'list'],
+    usage: 'orizu comments list (--prompt <id-or-name> --project <team/project> [--label <label> | --version <id>] | --run <run-id> | --task <task-id>) [--json]',
+    summary: 'List report comment threads with open/resolved status and replies.',
+    group: 'Report comments',
+    options: [
+      { name: '--prompt <id-or-name>', help: 'Prompt report target. Requires --project.' },
+      { name: '--project <team/project>', help: 'Project slug for prompt targets.' },
+      { name: '--label <label>', help: 'Prompt version label to comment on.' },
+      { name: '--version <id>', help: 'Prompt version ID to comment on.' },
+      { name: '--run <run-id>', help: 'Optimization run report target.' },
+      { name: '--task <task-id>', help: 'Task report target.' },
+      { name: '--json', help: 'Emit the full comments payload.' },
+    ],
+    examples: [
+      'orizu comments list --prompt Generator --project core/evals --label production',
+      'orizu comments list --run <run-id>',
+      'orizu comments list --task <task-id>',
+    ],
+  },
+  {
+    path: ['comments', 'add'],
+    usage: 'orizu comments add (--prompt <id-or-name> --project <team/project> [--label <label> | --version <id>] | --run <run-id> | --task <task-id>) --body <text|@file> [--anchor <text>] [--lines <start:end>] [--via <name>] [--json]',
+    summary: 'Add an anchored top-level comment to a report.',
+    group: 'Report comments',
+    options: [
+      { name: '--body <text|@file>', help: 'Comment body or @file reference.', required: true },
+      { name: '--anchor <text>', help: 'Quoted report text for the comment anchor.' },
+      { name: '--lines <start:end>', help: 'One-based inclusive line range for the anchor.' },
+      { name: '--via <name>', help: 'Tool or agent name to show in attribution.' },
+      { name: '--json', help: 'Emit the created comment payload.' },
+    ],
+    examples: [
+      'orizu comments add --run <run-id> --body @comment.md --anchor "Score summary" --lines 4:6',
+      'orizu comments add --task <task-id> --body "Clarify this finding" --via Codex',
+    ],
+  },
+  {
+    path: ['comments', 'reply'],
+    usage: 'orizu comments reply <comment-id> --body <text|@file> [--via <name>] [--json]',
+    summary: 'Reply to a top-level report comment thread.',
+    group: 'Report comments',
+  },
+  {
+    path: ['comments', 'resolve'],
+    usage: 'orizu comments resolve <comment-id> [--json]',
+    summary: 'Resolve a top-level report comment thread.',
+    group: 'Report comments',
+  },
+  {
+    path: ['comments', 'unresolve'],
+    usage: 'orizu comments unresolve <comment-id> [--json]',
+    summary: 'Reopen a resolved report comment thread.',
+    group: 'Report comments',
+  },
+  {
+    path: ['comments', 'edit'],
+    usage: 'orizu comments edit <comment-id> --body <text|@file> [--json]',
+    summary: 'Edit one of your report comments or replies.',
+    group: 'Report comments',
+  },
   {
     path: ['setup'],
     usage: 'orizu setup [--team <slug>] [--agent <claude|codex>]... [--workspace [path]|--no-workspace] [--validate] [--fix] [--no-symlinks] [--verbose] [--no-install] [--handoff|--no-handoff] [--launch <claude|codex>] [--skip-login] [--yes] [--dry-run] [--no-input|--non-interactive] [--json]',
@@ -125,7 +187,7 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
   },
   {
     path: ['install-skill'],
-    usage: 'orizu install-skill [--agent <claude|codex>]... [--scope global|project] [--mode auto|link|copy] [--target <target>]... [--yes] [--dry-run]',
+    usage: 'orizu install-skill [--agent <claude|codex|opencode>]... [--scope global|project] [--mode auto|link|copy] [--target <target>]... [--yes] [--dry-run]',
     summary: 'Install or repair the Orizu coding-agent skill.',
     group: 'Agent setup',
     aliases: [['skills', 'install']],
@@ -273,12 +335,6 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
     summary: 'Restore an archived prompt artifact to active status.',
     group: 'Prompts and judges',
   },
-  {
-    path: ['prompts', 'comments'],
-    usage: 'orizu prompts comments <prompt-id-or-name> --project <team/project> [--label <label> | --version <id>] [--json]',
-    summary: 'List prompt comment threads with open/resolved status and replies.',
-    group: 'Prompts and judges',
-  },
   {
     path: ['prompts', 'pull'],
     usage: 'orizu prompts pull <prompt-id-or-name> --project <team/project> --out <dir> [--label <label> | --version <id>] [--json]',
@@ -563,6 +619,20 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
       'orizu tasks report upload --task <taskId> --report @./report.md',
     ],
   },
+  {
+    path: ['tasks', 'report', 'get'],
+    usage: 'orizu tasks report get --task <taskId> [--json]',
+    summary: 'Read the Markdown report for a task.',
+    group: 'Tasks',
+    options: [
+      { name: '--task <taskId>', help: 'Task ID whose report should be read.', required: true },
+      { name: '--json', help: 'Emit the full report payload.' },
+    ],
+    examples: [
+      'orizu tasks report get --task <taskId>',
+      'orizu tasks report get --task <taskId> --json',
+    ],
+  },
   {
     path: ['tasks', 'pause'],
     usage: 'orizu tasks pause --task <taskId>',

package/src/hosted-bootstrap.ts

@@ -441,6 +441,58 @@ export async function bootstrapHostedSandbox(opts: HostedBootstrapOptions): Prom
       })
     }
 
+    // 4b — Stage the orizu-cli skill into the workspace so the agent discovers it
+    // (ALI-1044). Resolve the CLI's OWN vendored skill dir in-sandbox, preferring:
+    //   (1) $ORIZU_SKILL_SOURCE_DIR  — explicit override (also honored by the CLI's
+    //       skill-installer; the local-sim rehearsal sets it),
+    //   (2) `orizu skills path`      — the packaged vendor/skills/orizu-cli of the
+    //       globally-installed CLI (the production path),
+    //   (3) `$(npm root -g)/orizu/vendor/skills/orizu-cli` — belt fallback.
+    // Then SYMLINK it under <workspaceDir>/.claude/skills/orizu-cli, falling back
+    // to a copy if the symlink cannot be created. Non-fatal + recorded, exactly
+    // like the CLI install. Resolved paths stay in shell vars (never interpolated),
+    // so they cannot inject into the command.
+    currentStep = 'skill_staged'
+    const skillSkillsDirRel = `${workspaceDir}/.claude/skills`
+    const stage = await session.exec(
+      [
+        `mkdir -p ${skillSkillsDirRel}`,
+        // The staged skill is bootstrap-injected RUNTIME scaffolding (a symlink to
+        // the sandbox-local CLI vendor dir), NOT the agent's work. Exclude it
+        // repo-LOCALLY (.git/info/exclude — invisible to the diff, never committed)
+        // so auto-harvest's `git add -A` can't sweep it into the session branch and
+        // (ALI-1051) auto-apply a broken symlink to the customer's main.
+        `if [ -d ${workspaceDir}/.git ]; then printf '%s\\n' '/.claude/skills/' >> ${workspaceDir}/.git/info/exclude; fi`,
+        `src="${'${ORIZU_SKILL_SOURCE_DIR:-}'}"`,
+        `if [ -z "$src" ] || [ ! -d "$src" ]; then src="$(orizu skills path 2>/dev/null || true)"; fi`,
+        `if [ -z "$src" ] || [ ! -d "$src" ]; then r="$(npm root -g 2>/dev/null || true)"; if [ -n "$r" ] && [ -d "$r/orizu/vendor/skills/orizu-cli" ]; then src="$r/orizu/vendor/skills/orizu-cli"; fi; fi`,
+        `if [ -z "$src" ] || [ ! -d "$src" ]; then echo "NO_SOURCE"; exit 0; fi`,
+        `dest="${skillSkillsDirRel}/orizu-cli"`,
+        `rm -rf "$dest"`,
+        `if ln -s "$src" "$dest" 2>/dev/null; then echo "SYMLINK $src"; else cp -R "$src" "$dest" && echo "COPY $src"; fi`,
+      ].join('\n')
+    )
+    const stageOut = stage.stdout.trim()
+    const stagedMethod = stageOut.startsWith('SYMLINK')
+      ? 'symlink'
+      : stageOut.startsWith('COPY')
+        ? 'copy'
+        : null
+    const stagedOk = stage.exitCode === 0 && stagedMethod !== null
+    record(
+      'skill_staged',
+      stagedOk,
+      stagedOk
+        ? `orizu-cli skill staged (${stagedMethod})`
+        : `skill staging unresolved: ${stageOut || `exit ${stage.exitCode}`}`
+    )
+    await sink.append('skill_staged', {
+      ok: stagedOk,
+      method: stagedMethod,
+      dest: `${skillSkillsDirRel}/orizu-cli`,
+      outputTail: tail(stage.stdout, stage.stderr),
+    })
+
     // 5 — Customer setup hook (fresh-boot only, non-fatal, output captured).
     // P3-a: for enforced-egress providers the host DEFERS this hook to the loop,
     // which runs it AFTER the egress canary proves the firewall is live — so the

package/src/hosted-harness-opencode.ts

@@ -760,10 +760,32 @@ function errorEvent(messageId: string, error: unknown): HarnessEvent {
 export interface OpenCodeConfigOptions {
   /** Provider-qualified model string, e.g. "anthropic/claude-opus-4-8". */
   model: string
-  /** OpenCode permission map; defaults to allow-all (sandbox is the boundary). */
+  /** OpenCode permission map; defaults to allow-all EXCEPT the headless-denied
+   *  tools below (sandbox is the boundary for everything else). */
   permission?: Record<string, unknown>
 }
 
+/**
+ * Tools DENIED in a hosted headless run (ALI-1037). OpenCode exposes a `question`
+ * permission key (docs/permissions) that gates the interactive "ask the user a
+ * question" tool. In an unattended sandbox there is no human to answer it, and
+ * OpenCode's only external reply endpoint — `POST /session/{id}/permissions/{permID}`
+ * — takes a BOOLEAN allow/deny, so it cannot select one of the tool's multiple
+ * options anyway. Denying the tool makes the model's ask fail fast (surfaced back
+ * to it as a tool error) so it proceeds autonomously per the standing preamble
+ * (HOSTED_TASK_PREAMBLE), instead of blocking the run forever. This is the
+ * documented fallback path in ALI-1037 (answer-externally is not cleanly possible).
+ */
+export const HEADLESS_DENIED_TOOLS = ['question'] as const
+
+/** The default headless permission map: allow everything, deny the interactive
+ *  question tool (see HEADLESS_DENIED_TOOLS). */
+export function defaultHeadlessPermission(): Record<string, unknown> {
+  const permission: Record<string, unknown> = { '*': { '*': 'allow' } }
+  for (const tool of HEADLESS_DENIED_TOOLS) permission[tool] = 'deny'
+  return permission
+}
+
 /**
  * Build the `OPENCODE_CONFIG_CONTENT` payload OpenCode reads at boot (mirrors
  * OpenInspect's `start_opencode`). Kept pure so the launch command and the
@@ -772,7 +794,7 @@ export interface OpenCodeConfigOptions {
 export function buildOpenCodeConfigContent(opts: OpenCodeConfigOptions): string {
   return JSON.stringify({
     model: opts.model,
-    permission: opts.permission ?? { '*': { '*': 'allow' } },
+    permission: opts.permission ?? defaultHeadlessPermission(),
   })
 }
 

package/src/hosted-harness.ts

@@ -79,6 +79,15 @@ export const HARNESS_EVENT_KINDS = {
   // and never terminal, so they append like any structural event.
   egress_blocked: 'egress_blocked',
   egress_allowed: 'egress_allowed',
+  // Durability + headless (ALI-1036 / ALI-1037). NOT produced by a harness — the
+  // in-sandbox loop emits these through the SAME single-writer run-event sink:
+  // the end-of-run auto-harvest result (work_persisted/work_none/work_persist_failed)
+  // and the headless question auto-handling record (question_auto_answered). They
+  // are ordinary structural events (never terminal), appended like any other.
+  work_persisted: 'work_persisted',
+  work_none: 'work_none',
+  work_persist_failed: 'work_persist_failed',
+  question_auto_answered: 'question_auto_answered',
   error: 'error',
   execution_complete: 'execution_complete',
 } as const