@fitlab-ai/agent-infra 0.9.3 → 0.9.4

package/dist/lib/agent-clients/adapters/claude-code-sandbox.js

@@ -0,0 +1,247 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatCredentialWarnings, formatRemaining, hasClaudeProviderAuth, inspectClaudeKeychainStatus, prepareClaudeCredentials, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from './claude-code-credentials.js';
+function readHostJsonSafe(filePath) {
+    if (!filePath || !fs.existsSync(filePath))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+const CLAUDE_SETTINGS_INHERIT_TOP_LEVEL_KEYS = [
+    'model',
+    'fallbackModel',
+    'availableModels',
+    'modelOverrides',
+    'enforceAvailableModels',
+    'advisorModel',
+    'apiKeyHelper',
+    'effortLevel'
+];
+function isJsonObjectRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function mergeMissingStringEnvFields(target, source) {
+    if (!isJsonObjectRecord(source.env))
+        return false;
+    if (Object.hasOwn(target, 'env') && !isJsonObjectRecord(target.env))
+        return false;
+    let targetEnv = target.env;
+    let changed = false;
+    for (const [key, value] of Object.entries(source.env)) {
+        if (typeof value !== 'string' || value === '')
+            continue;
+        if (!targetEnv) {
+            targetEnv = {};
+            target.env = targetEnv;
+        }
+        if (!Object.hasOwn(targetEnv, key)) {
+            targetEnv[key] = value;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function mergeMissingTopLevelSettings(target, source) {
+    let changed = false;
+    for (const key of CLAUDE_SETTINGS_INHERIT_TOP_LEVEL_KEYS) {
+        if (!Object.hasOwn(source, key) || Object.hasOwn(target, key))
+            continue;
+        const value = source[key];
+        if (value === null || value === undefined || value === '')
+            continue;
+        target[key] = value;
+        changed = true;
+    }
+    return changed;
+}
+function requireCreateContext(context, hookId) {
+    if (!context)
+        throw new Error(`${hookId} requires create context`);
+    return context;
+}
+function requireEnterContext(context, hookId) {
+    if (!context)
+        throw new Error(`${hookId} requires enter context`);
+    return context;
+}
+export function ensureClaudeOnboarding(toolDir, hostHomeDir) {
+    const claudeJsonPath = path.join(toolDir, '.claude.json');
+    let data = {};
+    if (fs.existsSync(claudeJsonPath)) {
+        try {
+            data = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
+        }
+        catch {
+            // Malformed JSON is replaced with a valid managed sandbox baseline.
+        }
+    }
+    let changed = false;
+    if (!data.hasCompletedOnboarding) {
+        data.hasCompletedOnboarding = true;
+        changed = true;
+    }
+    if (!data.projects) {
+        data.projects = {};
+        changed = true;
+    }
+    if (!data.projects['/workspace']) {
+        data.projects['/workspace'] = {};
+        changed = true;
+    }
+    if (!data.projects['/workspace'].hasTrustDialogAccepted) {
+        data.projects['/workspace'].hasTrustDialogAccepted = true;
+        changed = true;
+    }
+    if (hostHomeDir) {
+        const hostClaudeJson = readHostJsonSafe(path.join(hostHomeDir, '.claude.json'));
+        if (hostClaudeJson
+            && typeof hostClaudeJson.model === 'string'
+            && hostClaudeJson.model !== ''
+            && !Object.hasOwn(data, 'model')) {
+            data.model = hostClaudeJson.model;
+            changed = true;
+        }
+        if (hostClaudeJson) {
+            for (const key of Object.keys(hostClaudeJson)) {
+                if (/^unpin.*LaunchEffort$/.test(key)
+                    && hostClaudeJson[key] === true
+                    && !Object.hasOwn(data, key)) {
+                    data[key] = true;
+                    changed = true;
+                }
+            }
+        }
+    }
+    if (changed)
+        fs.writeFileSync(claudeJsonPath, JSON.stringify(data, null, 4), 'utf8');
+}
+export function ensureClaudeSettings(toolDir, hostHomeDir) {
+    const settingsPath = path.join(toolDir, 'settings.json');
+    let data = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            data = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            // Malformed JSON is replaced with a valid managed sandbox baseline.
+        }
+    }
+    let changed = false;
+    if (data.skipDangerousModePermissionPrompt !== true) {
+        data.skipDangerousModePermissionPrompt = true;
+        changed = true;
+    }
+    if (hostHomeDir) {
+        const hostSettings = readHostJsonSafe(path.join(hostHomeDir, '.claude', 'settings.json'));
+        if (hostSettings) {
+            changed = mergeMissingStringEnvFields(data, hostSettings) || changed;
+            changed = mergeMissingTopLevelSettings(data, hostSettings) || changed;
+        }
+    }
+    if (changed)
+        fs.writeFileSync(settingsPath, JSON.stringify(data, null, 4), 'utf8');
+}
+export function formatCredentialSyncStatus(result, isTTY = process.stderr.isTTY, providerAuthAvailable = false) {
+    if (providerAuthAvailable && (result.status === 'STALE_ACCESS' || result.status === 'MISSING'))
+        return null;
+    if (result.status === 'STALE_ACCESS') {
+        return 'Warning: Claude Code credentials on host appear stale. Run "ai sandbox refresh" or "claude /login" to renew.\n';
+    }
+    if (result.status === 'MISSING') {
+        return 'Warning: Claude Code credentials missing on host. Run "claude /login" to authenticate.\n';
+    }
+    if (result.status === 'KEYCHAIN_WRITE_FAILED') {
+        return `Warning: A sandbox refresh produced newer credentials but host Keychain write failed (${formatCredentialWarnings(result.warnings)}). Run "ai sandbox refresh" again or "claude /status" on the host to retry.\n`;
+    }
+    if (result.status === 'KEYCHAIN_LOCKED' || result.status === 'KEYCHAIN_ERROR') {
+        return 'Warning: Host keychain is unavailable; Claude credential sync skipped. Run "ai sandbox refresh" for details.\n';
+    }
+    if (result.status === 'OK' && result.authoritative !== 'host') {
+        const message = `Synced Claude Code credentials from sandbox refresh back to host (expires in ${formatRemaining(result.expiresAt)})`;
+        return isTTY ? `\x1b[2m${message}\x1b[0m\n` : `${message}\n`;
+    }
+    if (result.status === 'OK' && result.filesWritten.length > 0) {
+        const message = `Synced Claude Code credentials from host Keychain (expires in ${formatRemaining(result.expiresAt)})`;
+        return isTTY ? `\x1b[2m${message}\x1b[0m\n` : `${message}\n`;
+    }
+    return null;
+}
+const claudeCodeCredentialPreflightHook = {
+    id: 'claude-code-credential-preflight',
+    phase: 'prepare',
+    run: async ({ create }) => {
+        const { hostHome, hostEnv, project, resolvedTools } = requireCreateContext(create, 'claude-code-credential-preflight');
+        try {
+            validateClaudeCredentialsEnvOverride(hostEnv);
+            const outcome = prepareClaudeCredentials(hostHome, project, [...resolvedTools], undefined, undefined, (home) => inspectClaudeKeychainStatus(home, undefined, { envFn: () => ({ ...hostEnv }) }));
+            if (outcome.status === 'SKIPPED') {
+                return {
+                    status: 'warning',
+                    message: 'Claude Code credentials not found on host - creating this sandbox WITHOUT Claude Code credentials.\n'
+                        + '  Claude Code is still installed in the image but will not be authenticated.\n'
+                        + '  To enable it: run "claude" once on the host to complete login, then re-run "ai sandbox create".'
+                };
+            }
+            return { status: 'ready' };
+        }
+        catch (error) {
+            return {
+                status: 'fatal',
+                message: redactCommandError(error instanceof Error ? error.message : 'unknown credential error')
+            };
+        }
+    }
+};
+const claudeCodeBeforeContainerCreateHook = {
+    id: 'claude-code-before-container-create',
+    phase: 'before-container-create',
+    run: async ({ create }) => {
+        const { hostHome, resolvedTools } = requireCreateContext(create, 'claude-code-before-container-create');
+        const claudeCodeEntry = resolvedTools.find(({ tool }) => tool.id === 'claude-code');
+        if (claudeCodeEntry) {
+            ensureClaudeOnboarding(claudeCodeEntry.dir, hostHome);
+            ensureClaudeSettings(claudeCodeEntry.dir, hostHome);
+        }
+        return { status: 'ready' };
+    }
+};
+const claudeCodeBeforeEnterHook = {
+    id: 'claude-code-before-enter',
+    phase: 'before-enter',
+    run: async ({ enter }) => {
+        const { hostHome, hostEnv } = requireEnterContext(enter, 'claude-code-before-enter');
+        try {
+            validateClaudeCredentialsEnvOverride(hostEnv);
+        }
+        catch (error) {
+            return {
+                status: 'fatal',
+                message: redactCommandError(error instanceof Error ? error.message : 'invalid credentials override')
+            };
+        }
+        try {
+            const providerAuthAvailable = hasClaudeProviderAuth(hostHome);
+            const result = reconcileClaudeCredentials(hostHome, { envFn: () => ({ ...hostEnv }) });
+            const message = formatCredentialSyncStatus(result, process.stderr.isTTY, providerAuthAvailable);
+            return {
+                status: 'ready',
+                ...(message === null ? {} : { message })
+            };
+        }
+        catch (error) {
+            return {
+                status: 'warning',
+                message: `Failed to sync Claude Code credentials: ${redactCommandError(error instanceof Error ? error.message : 'unknown error')}`
+            };
+        }
+    }
+};
+export { claudeCodeBeforeContainerCreateHook, claudeCodeBeforeEnterHook, claudeCodeCredentialPreflightHook };
+//# sourceMappingURL=claude-code-sandbox.js.map

package/dist/lib/agent-clients/adapters/claude-code.js

@@ -1,5 +1,6 @@
 import { defineAgentClientAdapter } from '../adapter.js';
 import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
+import { claudeCodeBeforeContainerCreateHook, claudeCodeBeforeEnterHook, claudeCodeCredentialPreflightHook } from './claude-code-sandbox.js';
 const claudeCodeAdapter = defineAgentClientAdapter({
     id: 'claude-code',
     displayName: 'Claude Code',
@@ -25,7 +26,7 @@ const claudeCodeAdapter = defineAgentClientAdapter({
     },
     project: {
         ownedPathPrefixes: ['.claude/'],
-        managed: ['.claude/commands/', '.claude/agents/'],
+        managed: ['.claude/commands/', '.claude/agents/', '.claude/rules/'],
         merged: ['.claude/settings.json'],
         ejected: [],
         seedCommands: [{
@@ -34,9 +35,18 @@ const claudeCodeAdapter = defineAgentClientAdapter({
                     'zh-CN': '.claude/commands/update-agent-infra.zh-CN.md'
                 },
                 target: '.claude/commands/update-agent-infra.md'
-            }]
+            }],
+        customCommand: {
+            target: '.claude/commands/${skillName}.md',
+            frontmatter: {},
+            includeUsage: true,
+            inheritDisableModelInvocation: true
+        }
     },
     sandbox: {
+        image: {
+            dockerfileFragment: 'claude-code'
+        },
         createTool: ({ home, project }) => ({
             id: 'claude-code',
             name: 'Claude Code',
@@ -64,7 +74,11 @@ const claudeCodeAdapter = defineAgentClientAdapter({
             { name: 'claude-yolo', command: 'claude --dangerously-skip-permissions; tput ed' },
             { name: 'cy', command: 'claude --dangerously-skip-permissions; tput ed' }
         ],
-        hooks: []
+        hooks: [
+            claudeCodeCredentialPreflightHook,
+            claudeCodeBeforeContainerCreateHook,
+            claudeCodeBeforeEnterHook
+        ]
     }
 });
 export { claudeCodeAdapter };

package/dist/lib/agent-clients/adapters/opencode-sandbox.js

@@ -0,0 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveXdgRoot(value, fallback) {
+    return typeof value === 'string' && value !== '' && path.isAbsolute(value)
+        ? value
+        : fallback;
+}
+function ensureOpenCodeSandboxState(toolDir, hostHome, hostEnv = {}) {
+    const canonicalConfigDir = path.join(toolDir, '.xdg', 'config', 'opencode');
+    const canonicalStateDir = path.join(toolDir, '.xdg', 'state', 'opencode');
+    const canonicalConfigPath = path.join(canonicalConfigDir, 'opencode.json');
+    const legacyConfigPath = path.join(toolDir, 'opencode.json');
+    fs.mkdirSync(canonicalConfigDir, { recursive: true });
+    fs.mkdirSync(canonicalStateDir, { recursive: true });
+    if (!fs.existsSync(canonicalConfigPath) && fs.existsSync(legacyConfigPath)) {
+        fs.copyFileSync(legacyConfigPath, canonicalConfigPath, fs.constants.COPYFILE_EXCL);
+    }
+    const hostConfigRoot = resolveXdgRoot(hostEnv.XDG_CONFIG_HOME, path.join(hostHome, '.config'));
+    const hostConfig = readJsonObject(path.join(hostConfigRoot, 'opencode', 'opencode.json'));
+    if (!hostConfig) {
+        return;
+    }
+    let sandboxConfig = {};
+    if (fs.existsSync(canonicalConfigPath)) {
+        const existing = readJsonObject(canonicalConfigPath);
+        if (!existing) {
+            return;
+        }
+        sandboxConfig = existing;
+    }
+    let changed = false;
+    for (const key of ['model', 'small_model']) {
+        if (Object.hasOwn(sandboxConfig, key)) {
+            continue;
+        }
+        const value = hostConfig[key];
+        if (typeof value === 'string' && value !== '') {
+            sandboxConfig[key] = value;
+            changed = true;
+        }
+    }
+    if (changed) {
+        fs.writeFileSync(canonicalConfigPath, JSON.stringify(sandboxConfig, null, 2), 'utf8');
+    }
+}
+const opencodeBeforeContainerCreateHook = {
+    id: 'opencode-before-container-create',
+    phase: 'before-container-create',
+    async run(context) {
+        const create = context.create;
+        const entry = create?.resolvedTools.find(({ tool }) => tool.id === 'opencode');
+        if (!create || !entry) {
+            return {
+                status: 'fatal',
+                message: 'OpenCode sandbox hook requires its resolved tool state.'
+            };
+        }
+        ensureOpenCodeSandboxState(entry.dir, create.hostHome, create.hostEnv);
+        return { status: 'ready' };
+    }
+};
+const opencodeRecoveryChecks = [
+    {
+        id: 'command-available',
+        probe: { script: 'command -v "$1"', args: ['opencode'] },
+        finding: {
+            repairKind: 'hard-failure',
+            message: 'OpenCode is not available on PATH inside the sandbox.'
+        }
+    },
+    {
+        id: 'config-writable',
+        probe: {
+            script: 'probe="$1/.agent-infra-opencode-config-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"',
+            args: ['/home/devuser/.local/share/opencode/.xdg/config/opencode']
+        },
+        finding: {
+            repairKind: 'permissions',
+            message: 'OpenCode config directory is not writable by devuser.',
+            path: '/home/devuser/.local/share/opencode/.xdg/config/opencode'
+        }
+    },
+    {
+        id: 'state-writable',
+        probe: {
+            script: 'probe="$1/.agent-infra-opencode-state-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"',
+            args: ['/home/devuser/.local/share/opencode/.xdg/state/opencode']
+        },
+        finding: {
+            repairKind: 'permissions',
+            message: 'OpenCode state directory is not writable by devuser.',
+            path: '/home/devuser/.local/share/opencode/.xdg/state/opencode'
+        }
+    }
+];
+export { ensureOpenCodeSandboxState, opencodeBeforeContainerCreateHook, opencodeRecoveryChecks };
+//# sourceMappingURL=opencode-sandbox.js.map

package/dist/lib/agent-clients/adapters/opencode.js

@@ -1,5 +1,6 @@
 import { defineAgentClientAdapter } from '../adapter.js';
 import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
+import { opencodeBeforeContainerCreateHook, opencodeRecoveryChecks } from './opencode-sandbox.js';
 const YOLO_PERMISSION = '{"*":"allow","read":"allow","bash":"allow","edit":"allow","webfetch":"allow","external_directory":"allow","doom_loop":"allow"}';
 const opencodeAdapter = defineAgentClientAdapter({
     id: 'opencode',
@@ -35,9 +36,17 @@ const opencodeAdapter = defineAgentClientAdapter({
                     'zh-CN': '.opencode/commands/update-agent-infra.zh-CN.md'
                 },
                 target: '.opencode/commands/update-agent-infra.md'
-            }]
+            }],
+        customCommand: {
+            target: '.opencode/commands/${skillName}.md',
+            frontmatter: { agent: 'general', subtask: false },
+            argumentsToken: '$ARGUMENTS'
+        }
     },
     sandbox: {
+        image: {
+            dotfilesExclusions: ['.config/opencode']
+        },
         createTool: ({ home }) => ({
             id: 'opencode',
             name: 'OpenCode',
@@ -47,7 +56,9 @@ const opencodeAdapter = defineAgentClientAdapter({
             versionCmd: 'opencode --version',
             setupHint: 'Configure OpenCode credentials inside the container before first use.',
             envVars: {
-                OPENCODE_CONFIG: '/home/devuser/.local/share/opencode/opencode.json'
+                XDG_DATA_HOME: '/home/devuser/.local/share',
+                XDG_CONFIG_HOME: '/home/devuser/.local/share/opencode/.xdg/config',
+                XDG_STATE_HOME: '/home/devuser/.local/share/opencode/.xdg/state'
             },
             hostLiveMounts: [
                 {
@@ -66,7 +77,8 @@ const opencodeAdapter = defineAgentClientAdapter({
                 command: `OPENCODE_PERMISSION='${YOLO_PERMISSION}' opencode; tput ed`
             }
         ],
-        hooks: []
+        hooks: [opencodeBeforeContainerCreateHook],
+        recoveryChecks: opencodeRecoveryChecks
     }
 });
 export { opencodeAdapter };

package/dist/lib/agent-clients/adapters/runtimes/claude-code.dockerfile

@@ -0,0 +1,65 @@
+RUN cat > /usr/local/bin/cc-token-status <<'SCRIPT' && chmod +x /usr/local/bin/cc-token-status
+#!/bin/sh
+set -eu
+
+SETTINGS_FILE="/home/devuser/.claude/settings.json"
+if [ -r "$SETTINGS_FILE" ] && jq -e '
+  def has_nonempty($v):
+    if ($v | type) == "string" then ($v | gsub("^\\s+|\\s+$"; "") | length) > 0 else false end;
+  (if type == "object" then . else {} end) as $settings
+  | (if ($settings.env | type) == "object" then $settings.env else {} end) as $env
+  | has_nonempty($env.ANTHROPIC_AUTH_TOKEN)
+    or has_nonempty($env.ANTHROPIC_API_KEY)
+    or has_nonempty($settings.apiKeyHelper)
+' "$SETTINGS_FILE" >/dev/null 2>&1; then
+  exit 0
+fi
+
+CRED_FILE="/home/devuser/.claude/.credentials.json"
+[ -r "$CRED_FILE" ] || exit 0
+
+EXPIRES_MS=$(jq -r '(.claudeAiOauth.expiresAt // .expiresAt) // empty' "$CRED_FILE" 2>/dev/null || true)
+case "$EXPIRES_MS" in
+  ''|*[!0-9]*) exit 0 ;;
+esac
+
+NOW_MS=$(($(date +%s) * 1000))
+DIFF_MS=$((EXPIRES_MS - NOW_MS))
+DIFF_S=$((DIFF_MS / 1000))
+
+DIM='#[fg=colour245]'
+YELLOW='#[fg=yellow]'
+YELLOW_BOLD='#[fg=yellow,bold]'
+RED_BOLD='#[fg=red,bold]'
+RED_REV='#[fg=red,reverse]'
+RESET='#[default]'
+
+if [ "$DIFF_S" -le 0 ]; then
+  ELAPSED=$(( -DIFF_S ))
+  M=$((ELAPSED / 60))
+  printf '%sClaude Code auth EXPIRED %dm ago%s' "$RED_REV" "$M" "$RESET"
+elif [ "$DIFF_S" -lt 60 ]; then
+  printf '%sClaude Code auth expires in %ds%s' "$RED_BOLD" "$DIFF_S" "$RESET"
+elif [ "$DIFF_S" -lt 300 ]; then
+  M=$((DIFF_S / 60))
+  S=$((DIFF_S % 60))
+  printf '%sClaude Code auth expires in %dm %ds%s' "$RED_BOLD" "$M" "$S" "$RESET"
+elif [ "$DIFF_S" -lt 1800 ]; then
+  M=$((DIFF_S / 60))
+  printf '%sClaude Code auth expires in %dm%s' "$YELLOW_BOLD" "$M" "$RESET"
+elif [ "$DIFF_S" -lt 3600 ]; then
+  M=$((DIFF_S / 60))
+  printf '%sClaude Code auth expires in %dm%s' "$YELLOW" "$M" "$RESET"
+else
+  TOTAL_M=$((DIFF_S / 60))
+  H=$((TOTAL_M / 60))
+  M=$((TOTAL_M % 60))
+  printf '%sClaude Code auth expires in %dh %dm%s' "$DIM" "$H" "$M" "$RESET"
+fi
+SCRIPT
+
+RUN test -s /usr/local/bin/cc-token-status && test -x /usr/local/bin/cc-token-status
+
+RUN printf '%s\n' \
+      "set -g status-right '#(/usr/local/bin/cc-token-status) | %H:%M'" \
+    >> /etc/tmux.conf

package/dist/lib/agent-clients/registry.js

@@ -71,7 +71,15 @@ function createAgentClientManifest() {
         ownedPathPrefixes: Object.freeze([...adapter.project.ownedPathPrefixes]),
         managed: Object.freeze([...adapter.project.managed]),
         merged: Object.freeze([...adapter.project.merged]),
-        ejected: Object.freeze([...adapter.project.ejected])
+        ejected: Object.freeze([...adapter.project.ejected]),
+        ...(adapter.project.customCommand === undefined
+            ? {}
+            : {
+                customCommand: Object.freeze({
+                    ...adapter.project.customCommand,
+                    frontmatter: Object.freeze({ ...adapter.project.customCommand.frontmatter })
+                })
+            })
     })));
 }
 export { AGENT_CLIENT_REGISTRY, createAgentClientManifest, getAgentClientAdapter, getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection, listAgentClientAdapters, listEnabledAgentClientAdapters, listEnabledAgentClientAdaptersByCapability, listInstalledAgentClientAdapters };

package/dist/lib/internal/sandbox-control.js

@@ -0,0 +1,24 @@
+import { requestSandboxControl } from '../sandbox/control/client.js';
+import { serveSandboxControl } from '../sandbox/control/server.js';
+function sandboxControl(args) {
+    const [operation, ...rest] = args;
+    if (operation === 'serve') {
+        const manifestIndex = rest.indexOf('--manifest');
+        const manifest = manifestIndex >= 0 ? rest[manifestIndex + 1] : undefined;
+        if (!manifest)
+            throw new Error('sandbox-control serve requires --manifest');
+        serveSandboxControl(manifest);
+        return;
+    }
+    if (operation === 'client') {
+        const [family = '', ...commandArgs] = rest;
+        const response = requestSandboxControl({ family, args: commandArgs });
+        process.stdout.write(response.stdout);
+        process.stderr.write(response.stderr);
+        process.exitCode = response.exitCode;
+        return;
+    }
+    throw new Error('Usage: agent-infra-internal sandbox-control serve --manifest <path> | client <family> [args...]');
+}
+export { sandboxControl };
+//# sourceMappingURL=sandbox-control.js.map

package/dist/lib/internal/task-activity.js

@@ -1,11 +1,27 @@
-import { applyActivityAppendIntent } from '../task/activity-intent.js';
-const USAGE = `Usage: agent-infra-internal task-activity <task-ref> append --step <step> --agent <agent> --note <note> [--artifact <canonical.md>] [--dry-run]
+import { applyPrReviewActivityIntent, inspectPrReviewActivity } from '../task/activity-intent.js';
+const USAGE = `Usage: agent-infra-internal task-activity <task-ref> pr-review-inspect
+       agent-infra-internal task-activity <task-ref> pr-review-start --agent <agent> --artifact <canonical.md> --head <40hex> [--dry-run]
+       agent-infra-internal task-activity <task-ref> pr-review-complete --agent <agent> --artifact <canonical.md> --head <40hex> --verdict <approved|changes-requested|commented> --blockers <N> --major <N> --minor <N> [--dry-run]
+       agent-infra-internal task-activity <task-ref> pr-review-terminate --agent <agent> --artifact <canonical.md> --head <40hex> --outcome <aborted|superseded> --reason <single-line> [--dry-run]
 `;
+const OPERATIONS = new Set(['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate']);
 const FLAGS = {
-    '--step': 'step',
     '--agent': 'agent',
-    '--note': 'note',
-    '--artifact': 'artifact'
+    '--artifact': 'artifact',
+    '--head': 'head',
+    '--verdict': 'verdict',
+    '--blockers': 'blockers',
+    '--major': 'major',
+    '--minor': 'minor',
+    '--outcome': 'outcome',
+    '--reason': 'reason'
+};
+const COMMON = ['agent', 'artifact', 'head'];
+const ALLOWED = {
+    'pr-review-inspect': new Set(['kind', 'taskRef']),
+    'pr-review-start': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'dryRun']),
+    'pr-review-complete': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'verdict', 'blockers', 'major', 'minor', 'dryRun']),
+    'pr-review-terminate': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'outcome', 'reason', 'dryRun'])
 };
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ACTIVITY_PAYLOAD_INVALID', message } })}\n`);
@@ -18,8 +34,8 @@ function taskActivity(args = []) {
         return;
     }
     const [taskRef, kind] = args;
-    if (!taskRef || taskRef.startsWith('--') || !kind || kind !== 'append') {
-        usageFailure('task ref and the append intent are required');
+    if (!taskRef || taskRef.startsWith('--') || !kind || !OPERATIONS.has(kind)) {
+        usageFailure('task ref and a supported PR review intent are required');
         return;
     }
     const values = { kind, taskRef };
@@ -50,21 +66,37 @@ function taskActivity(args = []) {
             return;
         }
         seen.add(flag);
-        values[key] = value;
+        values[key] = ['blockers', 'major', 'minor'].includes(key) ? Number(value) : value;
     }
-    const allowed = new Set(['kind', 'taskRef', 'dryRun', 'step', 'agent', 'note', 'artifact']);
+    const allowed = ALLOWED[kind];
     const unexpected = Object.keys(values).find((key) => !allowed.has(key));
     if (unexpected) {
-        usageFailure(`append does not accept '${unexpected}'`);
+        usageFailure(`${kind} does not accept '${unexpected}'`);
+        return;
+    }
+    if (kind === 'pr-review-inspect') {
+        const result = inspectPrReviewActivity(values);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (result.status === 'failed')
+            process.exitCode = 1;
         return;
     }
-    for (const key of ['step', 'agent', 'note']) {
+    for (const key of COMMON) {
+        if (values[key] === undefined) {
+            usageFailure(`${kind} requires '${key}'`);
+            return;
+        }
+    }
+    const operationRequired = kind === 'pr-review-complete'
+        ? ['verdict', 'blockers', 'major', 'minor']
+        : kind === 'pr-review-terminate' ? ['outcome', 'reason'] : [];
+    for (const key of operationRequired) {
         if (values[key] === undefined) {
-            usageFailure(`append requires '${key}'`);
+            usageFailure(`${kind} requires '${key}'`);
             return;
         }
     }
-    const result = applyActivityAppendIntent(values);
+    const result = applyPrReviewActivityIntent(values);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;