@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/process-data/normalize.js

@@ -1,192 +1,8 @@
 import { sha256 } from './store.js';
-import { normalizeAgentToken } from '../agent-clients/tokens.js';
 const TASK_ID_RE = /TASK-\d{8}-\d{6}/;
-const ACTIVITY_RE = /^- (\d{4}-\d{2}-\d{2} [^ ]+) — \*\*(.+?)\*\* by ([^ ]+) — (.+)$/gm;
-const LEDGER_RE = /^\|\s*((?:AN|PL|CD)-\d+)\s*\|\s*(analysis|plan|code)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|$/gm;
-const RULING_RE = /^###\s+(HDR-\d+)\s*$([\s\S]*?)(?=^###\s+|^##\s+|(?![\s\S]))/gm;
-const CONFLICT_STATUSES = new Set(['open', 'accepted', 'adjusted', 'refuted', 'cannot-judge', 'needs-human-decision']);
 function recordId(kind, identity, suffix = '') {
     return `${kind}:${sha256(`${identity}\0${suffix}`).slice(0, 24)}`;
 }
-function canonicalActor(raw) {
-    const lowered = raw.toLowerCase();
-    return normalizeAgentToken(lowered);
-}
-function nextOccurrence(occurrences, identity) {
-    const occurrence = (occurrences.get(identity) ?? 0) + 1;
-    occurrences.set(identity, occurrence);
-    return occurrence === 1 ? '' : `occurrence=${occurrence}`;
-}
-function normalizePlatformPage(object) {
-    if (!object.content)
-        return [];
-    try {
-        const page = JSON.parse(object.content);
-        if (!Array.isArray(page))
-            return [];
-        return page.map((entry, index) => {
-            const value = entry;
-            const identity = String(value.id ?? value.node_id ?? value.sha ?? value.number ?? `${object.sourceIdentity}:${index}`);
-            const platformIdentity = /\/issues\?/.test(object.sourceIdentity) && typeof value.number === 'number'
-                ? `issue:${value.number}`
-                : /\/pulls\?/.test(object.sourceIdentity) && typeof value.number === 'number'
-                    ? `pr:${value.number}`
-                    : /\/issues\/\d+\/comments/.test(object.sourceIdentity)
-                        ? `issue-comment:${identity}`
-                        : /\/pulls\/\d+\/reviews/.test(object.sourceIdentity)
-                            ? `review:${identity}`
-                            : /\/pulls\/\d+\/commits/.test(object.sourceIdentity)
-                                ? `commit:${identity}`
-                                : `platform:${identity}`;
-            const binding = typeof value.body === 'string' ? value.body.match(TASK_ID_RE)?.[0] : undefined;
-            return {
-                recordId: recordId('platform-resource', object.sourceIdentity, identity),
-                kind: 'platform-resource',
-                sourceIdentity: platformIdentity,
-                sourceSha256: object.sha256,
-                ...(binding ? { binding } : {}),
-                data: entry
-            };
-        });
-    }
-    catch {
-        return [];
-    }
-}
-function normalizeObjects(objects) {
-    const records = [];
-    for (const object of objects) {
-        if (object.disposition?.state && object.disposition.state !== 'included') {
-            records.push({
-                recordId: recordId('missing', object.sourceIdentity),
-                kind: 'missing',
-                sourceIdentity: object.sourceIdentity,
-                sourceSha256: object.sha256,
-                data: object.disposition.state === 'excluded-sensitive'
-                    ? { reason: 'privacy-excluded', ruleId: object.disposition.ruleId }
-                    : { reason: object.disposition.reason }
-            });
-            continue;
-        }
-        if (object.sourceKind === 'github-rest') {
-            records.push(...normalizePlatformPage(object));
-            continue;
-        }
-        if (object.sourceKind === 'operational-report') {
-            records.push({
-                recordId: recordId('operational-report', object.sourceIdentity),
-                kind: 'operational-report',
-                sourceIdentity: object.sourceIdentity,
-                sourceSha256: object.sha256
-            });
-            continue;
-        }
-        if (object.sourceKind === 'structured-telemetry') {
-            let data = { availability: 'unknown' };
-            try {
-                data = JSON.parse(object.content ?? '{}');
-            }
-            catch {
-                data = { availability: 'unavailable', reason: 'invalid receipt JSON' };
-            }
-            records.push({
-                recordId: recordId('telemetry', object.sourceIdentity),
-                kind: 'telemetry',
-                sourceIdentity: object.sourceIdentity,
-                sourceSha256: object.sha256,
-                data
-            });
-            continue;
-        }
-        const taskId = object.sourceIdentity.match(TASK_ID_RE)?.[0];
-        if (/\/task\.md$/.test(object.sourceIdentity) && taskId) {
-            const activityOccurrences = new Map();
-            const findingOccurrences = new Map();
-            const issueNumber = object.content?.match(/^issue_number:\s*(\d+)$/m)?.[1];
-            const agentInfraVersion = object.content?.match(/^agent_infra_version:\s*(\S+)$/m)?.[1];
-            records.push({
-                recordId: recordId('task', taskId),
-                kind: 'task',
-                sourceIdentity: taskId,
-                sourceSha256: object.sha256,
-                ...(issueNumber ? { binding: `issue:${issueNumber}` } : {}),
-                data: {
-                    agentInfraVersion: agentInfraVersion
-                        ? { state: 'known', value: agentInfraVersion }
-                        : { state: 'unknown', reason: 'legacy-task-missing-agent-infra-version' }
-                }
-            });
-            for (const match of object.content?.matchAll(ACTIVITY_RE) ?? []) {
-                const rawActor = match[3];
-                const identity = `${match[1]}:${match[2]}`;
-                const occurrence = nextOccurrence(activityOccurrences, identity);
-                records.push({
-                    recordId: recordId('lifecycle-event', taskId, occurrence ? `${identity}\0${occurrence}` : identity),
-                    kind: 'lifecycle-event',
-                    sourceIdentity: `${taskId}#activity=${match[1]}`,
-                    sourceSha256: object.sha256,
-                    data: {
-                        timestamp: match[1],
-                        action: match[2],
-                        actorRaw: rawActor,
-                        actorCanonical: canonicalActor(rawActor),
-                        note: match[4]
-                    }
-                });
-            }
-            for (const match of object.content?.matchAll(LEDGER_RE) ?? []) {
-                const findingId = match[1].trim();
-                const stage = match[2].trim();
-                const round = match[3].trim();
-                const severity = match[4].trim();
-                const status = match[5].trim();
-                const evidence = match[6].trim();
-                const identity = `${taskId}#finding=${findingId}`;
-                const occurrence = nextOccurrence(findingOccurrences, identity);
-                const data = { findingId, stage, round, severity, status, evidence };
-                records.push({
-                    recordId: recordId('review-finding', identity, occurrence),
-                    kind: 'review-finding',
-                    sourceIdentity: identity,
-                    sourceSha256: object.sha256,
-                    binding: taskId,
-                    data
-                });
-                if (status && CONFLICT_STATUSES.has(status)) {
-                    records.push({
-                        recordId: recordId('conflict', identity, occurrence),
-                        kind: 'conflict',
-                        sourceIdentity: `${identity}#status=${status}`,
-                        sourceSha256: object.sha256,
-                        binding: taskId,
-                        data
-                    });
-                }
-            }
-            for (const match of object.content?.matchAll(RULING_RE) ?? []) {
-                const rulingId = match[1];
-                const identity = `${taskId}#ruling=${rulingId}`;
-                records.push({
-                    recordId: recordId('human-ruling', identity),
-                    kind: 'human-ruling',
-                    sourceIdentity: identity,
-                    sourceSha256: object.sha256,
-                    binding: taskId,
-                    data: { rulingId, evidence: match[2].trim() }
-                });
-            }
-            continue;
-        }
-        records.push({
-            recordId: recordId('artifact', object.sourceIdentity),
-            kind: 'artifact',
-            sourceIdentity: object.sourceIdentity,
-            sourceSha256: object.sha256,
-            ...(taskId ? { binding: taskId } : {})
-        });
-    }
-    return records.sort((left, right) => left.recordId.localeCompare(right.recordId));
-}
 function normalizeResources(objects) {
     const records = [];
     for (const object of objects) {
@@ -220,5 +36,5 @@ function normalizeResources(objects) {
     }
     return records.sort((left, right) => left.recordId.localeCompare(right.recordId));
 }
-export { normalizeObjects, normalizeResources };
+export { normalizeResources };
 //# sourceMappingURL=normalize.js.map

package/dist/lib/process-data/privacy.js

@@ -1,4 +1,3 @@
-import { sha256 } from './store.js';
 const RULES = [
     { id: 'private-key', pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/ },
     { id: 'github-token', pattern: /\b(?:gh[opusr]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/ },
@@ -15,19 +14,5 @@ function inspectPrivacy(content) {
     }
     return { state: 'included' };
 }
-function captureText(sourceKind, sourceIdentity, content) {
-    const bytes = Buffer.byteLength(content);
-    const digest = sha256(Buffer.from(content, 'utf8'));
-    const disposition = inspectPrivacy(content);
-    return disposition.state === 'included'
-        ? { sourceKind, sourceIdentity, sha256: digest, bytes, content, disposition }
-        : { sourceKind, sourceIdentity, sha256: digest, bytes, disposition };
-}
-function redactExcerpt(content, maxBytes = 4096) {
-    if (inspectPrivacy(content).state !== 'included')
-        return null;
-    const buffer = Buffer.from(content, 'utf8');
-    return buffer.subarray(0, maxBytes).toString('utf8').replace(/\b(token|password|secret)=\S+/gi, '$1=[REDACTED]');
-}
-export { captureText, inspectPrivacy, redactExcerpt };
+export { inspectPrivacy };
 //# sourceMappingURL=privacy.js.map

package/dist/lib/process-data/sources.js

@@ -1,222 +1,6 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { createGitHubClient } from '../platform/github-client.js';
-import { enumerateAllTaskDirs } from '../task/resolve-ref.js';
-import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
-import { captureText, inspectPrivacy, redactExcerpt } from './privacy.js';
+import { inspectPrivacy } from './privacy.js';
 import { canonicalJsonBytes, sha256 } from './store.js';
-function endpointForPage(endpoint, page, perPage) {
-    const parsed = new URL(endpoint, 'https://api.github.invalid/');
-    if (parsed.searchParams.has('page') || parsed.searchParams.has('per_page')) {
-        throw new Error('endpoint must not predefine page or per_page');
-    }
-    parsed.searchParams.set('per_page', String(perPage));
-    parsed.searchParams.set('page', String(page));
-    return `${parsed.pathname.replace(/^\//, '')}${parsed.search}`;
-}
-function fetchRestCollection(options) {
-    const perPage = options.perPage ?? 100;
-    if (!Number.isInteger(perPage) || perPage < 1 || perPage > 100) {
-        return { ok: false, error: { code: 'PAGINATION_INVALID', message: 'perPage must be between 1 and 100' } };
-    }
-    let pageIndex = 1;
-    let previousHash = null;
-    const identities = new Set();
-    const items = [];
-    const pages = [];
-    while (true) {
-        let url;
-        try {
-            url = endpointForPage(options.endpoint, pageIndex, perPage);
-        }
-        catch (error) {
-            return { ok: false, error: { code: 'PAGINATION_INVALID', message: String(error) } };
-        }
-        const response = options.client.json(['api', url]);
-        if (!response.ok)
-            return { ok: false, error: response.error };
-        if (!Array.isArray(response.value) || response.value.length > perPage) {
-            return {
-                ok: false,
-                error: { code: 'INVALID_PLATFORM_RESPONSE', message: `GitHub page ${pageIndex} is not a valid array page` }
-            };
-        }
-        let selected;
-        try {
-            selected = response.value.map((entry) => options.select ? options.select(entry) : entry);
-        }
-        catch (error) {
-            return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: String(error) } };
-        }
-        let bytes;
-        try {
-            bytes = canonicalJsonBytes(selected);
-        }
-        catch (error) {
-            return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: String(error) } };
-        }
-        const canonicalSha256 = sha256(bytes);
-        if (previousHash === canonicalSha256 && response.value.length > 0) {
-            return {
-                ok: false,
-                error: { code: 'PAGINATION_UNSTABLE', message: `GitHub page ${pageIndex} repeats the previous page` }
-            };
-        }
-        for (const entry of selected) {
-            const identity = options.identify(entry);
-            if (!identity || identities.has(identity)) {
-                return {
-                    ok: false,
-                    error: { code: 'PAGINATION_UNSTABLE', message: `duplicate or empty identity on page ${pageIndex}` }
-                };
-            }
-            identities.add(identity);
-            items.push(entry);
-        }
-        pages.push({ evidence: { index: pageIndex, itemCount: response.value.length, canonicalSha256 }, bytes });
-        previousHash = canonicalSha256;
-        if (response.value.length < perPage)
-            break;
-        pageIndex += 1;
-    }
-    const evidence = {
-        endpoint: options.endpoint,
-        requestCount: pages.length,
-        dataPageCount: pages.filter((page) => page.evidence.itemCount > 0).length,
-        itemCount: items.length,
-        termination: 'short-page',
-        pages: pages.map((page) => page.evidence)
-    };
-    return {
-        ok: true,
-        value: {
-            items,
-            evidence,
-            pageObjects: pages.map((page) => ({
-                sourceKind: 'github-rest',
-                sourceIdentity: `${options.endpoint}#page=${page.evidence.index}`,
-                sha256: page.evidence.canonicalSha256,
-                bytes: page.bytes.length,
-                content: page.bytes.toString('utf8'),
-                disposition: { state: 'included' }
-            }))
-        }
-    };
-}
-function relativeIdentity(repoRoot, filePath) {
-    const workspaceRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
-    const taskRelative = path.relative(workspaceRoot, filePath);
-    if (taskRelative && !taskRelative.startsWith('..') && !path.isAbsolute(taskRelative)) {
-        return path.posix.join('task-workspace', taskRelative.split(path.sep).join('/'));
-    }
-    const relative = path.relative(repoRoot, filePath);
-    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
-        throw new Error(`path escapes repository: ${filePath}`);
-    return relative.split(path.sep).join('/');
-}
-function readStableFile(repoRoot, filePath, sourceKind) {
-    const before = fs.lstatSync(filePath);
-    if (!before.isFile() || before.isSymbolicLink())
-        throw new Error(`unsafe source file: ${filePath}`);
-    const content = fs.readFileSync(filePath, 'utf8');
-    const after = fs.lstatSync(filePath);
-    if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
-        throw new Error(`source changed while reading: ${filePath}`);
-    }
-    return captureText(sourceKind, relativeIdentity(repoRoot, filePath), content);
-}
-function listFiles(directory) {
-    if (!fs.existsSync(directory))
-        return [];
-    const output = [];
-    const walk = (current) => {
-        for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-            const candidate = path.join(current, entry.name);
-            if (entry.isSymbolicLink())
-                throw new Error(`symlink source is not allowed: ${candidate}`);
-            if (entry.isDirectory())
-                walk(candidate);
-            else if (entry.isFile())
-                output.push(candidate);
-        }
-    };
-    walk(directory);
-    return output;
-}
-function structuredReceipt(repoRoot, filePath) {
-    const raw = readStableFile(repoRoot, filePath, 'structured-telemetry');
-    if (!raw.content)
-        return raw;
-    try {
-        const parsed = JSON.parse(raw.content);
-        const fields = ['client', 'model', 'reasoning', 'stage', 'toolCategory', 'time', 'status', 'retry', 'error', 'fallback'];
-        const selected = Object.fromEntries(fields.filter((field) => parsed[field] !== undefined).map((field) => [field, jsonClone(parsed[field])]));
-        selected.sourceSha256 = raw.sha256;
-        return captureText('structured-telemetry', raw.sourceIdentity, canonicalJsonBytes(selected).toString('utf8'));
-    }
-    catch {
-        return { ...raw, content: undefined, disposition: { state: 'unavailable', reason: 'invalid receipt JSON' } };
-    }
-}
-function unavailableLog(repoRoot, filePath, includeExcerpts) {
-    const raw = readStableFile(repoRoot, filePath, 'local-file');
-    if (raw.disposition?.state === 'excluded-sensitive')
-        return raw;
-    const recognizedBody = /\/(?:sessions?|tools?)(?:\/|[-_])/i.test(raw.sourceIdentity);
-    if (includeExcerpts && recognizedBody && raw.content) {
-        const excerpt = redactExcerpt(raw.content);
-        if (excerpt !== null)
-            return captureText('local-file', `${raw.sourceIdentity}#excerpt`, excerpt);
-    }
-    return {
-        sourceKind: 'local-file',
-        sourceIdentity: raw.sourceIdentity,
-        sha256: raw.sha256,
-        bytes: raw.bytes,
-        disposition: { state: 'unavailable', reason: recognizedBody ? 'body-excerpts-disabled' : 'unknown-log-format' }
-    };
-}
-function collectLocalObjects(repoRoot, options = {}) {
-    try {
-        const objects = [];
-        for (const task of enumerateAllTaskDirs(repoRoot)) {
-            for (const filePath of listFiles(task.taskDir)) {
-                if (!/\.(?:md|json)$/i.test(filePath))
-                    continue;
-                objects.push(readStableFile(repoRoot, filePath, 'local-file'));
-            }
-        }
-        const logsRoot = path.join(repoRoot, '.agents', 'workspace', 'logs');
-        for (const filePath of listFiles(logsRoot)) {
-            if (!/\.(?:md|json)$/i.test(filePath))
-                continue;
-            const identity = relativeIdentity(repoRoot, filePath);
-            if (/\/entropy-check\/.*\.md$/i.test(identity)) {
-                objects.push(readStableFile(repoRoot, filePath, 'operational-report'));
-            }
-            else if (/\/(?:delegation|orchestration)(?:\/|[-_]).*\.json$/i.test(identity)) {
-                objects.push(structuredReceipt(repoRoot, filePath));
-            }
-            else {
-                objects.push(unavailableLog(repoRoot, filePath, options.includeExcerpts === true));
-            }
-        }
-        return { ok: true, value: objects.sort((a, b) => a.sourceIdentity.localeCompare(b.sourceIdentity)) };
-    }
-    catch (error) {
-        return { ok: false, error: { code: 'LOCAL_SOURCE_UNSTABLE', message: error instanceof Error ? error.message : String(error) } };
-    }
-}
-function githubIdentity(item) {
-    if (!item || typeof item !== 'object')
-        return '';
-    const record = item;
-    for (const key of ['id', 'node_id', 'sha', 'number']) {
-        if (typeof record[key] === 'string' || typeof record[key] === 'number')
-            return `${key}:${String(record[key])}`;
-    }
-    return '';
-}
 function jsonClone(value) {
     return JSON.parse(JSON.stringify(value));
 }
@@ -323,67 +107,6 @@ function projectGitHubTimelineItem(item) {
         output.body = body;
     return output;
 }
-function collectGitHubObjects(repoRoot, client = createGitHubClient()) {
-    const repoResult = client.json(['repo', 'view', '--json', 'nameWithOwner'], { cwd: repoRoot });
-    if (!repoResult.ok)
-        return { ok: false, error: repoResult.error };
-    const repository = repoResult.value.nameWithOwner;
-    if (!repository || !/^[^/]+\/[^/]+$/.test(repository)) {
-        return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'GitHub repository identity is missing' } };
-    }
-    const objects = [];
-    const evidence = [];
-    const captureEndpoint = (endpoint) => {
-        const result = fetchRestCollection({
-            client,
-            endpoint,
-            identify: githubIdentity,
-            select: (item) => projectGitHubItem(item)
-        });
-        if (!result.ok)
-            return result;
-        objects.push(...result.value.pageObjects);
-        evidence.push(result.value.evidence);
-        return result;
-    };
-    const issues = captureEndpoint(`repos/${repository}/issues?state=all&sort=created&direction=asc`);
-    if (!issues.ok)
-        return issues;
-    const pulls = captureEndpoint(`repos/${repository}/pulls?state=all&sort=created&direction=asc`);
-    if (!pulls.ok)
-        return pulls;
-    for (const issue of issues.value.items) {
-        const number = issue.number;
-        if (typeof number !== 'number')
-            return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'Issue number is missing' } };
-        const comments = captureEndpoint(`repos/${repository}/issues/${number}/comments`);
-        if (!comments.ok)
-            return comments;
-    }
-    for (const pull of pulls.value.items) {
-        const record = pull;
-        const number = record.number;
-        const head = record.head;
-        const headSha = head?.sha;
-        if (typeof number !== 'number' || typeof headSha !== 'string') {
-            return { ok: false, error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'Pull request identity or head SHA is missing' } };
-        }
-        for (const suffix of ['comments', 'reviews', 'commits']) {
-            const nested = captureEndpoint(`repos/${repository}/pulls/${number}/${suffix}`);
-            if (!nested.ok)
-                return nested;
-        }
-        const current = client.json(['api', `repos/${repository}/pulls/${number}`]);
-        if (!current.ok)
-            return { ok: false, error: current.error };
-        const projected = projectGitHubItem(current.value);
-        const currentHead = projected.head;
-        if (currentHead?.sha !== headSha) {
-            return { ok: false, error: { code: 'SOURCE_DRIFT', message: `Pull request ${number} head changed during capture` } };
-        }
-    }
-    return { ok: true, value: { repository, objects, endpoints: evidence } };
-}
 function resolveGitHubRepository(repoRoot, client = createGitHubClient()) {
     const result = client.json(['repo', 'view', '--json', 'nameWithOwner'], { cwd: repoRoot });
     if (!result.ok)
@@ -768,5 +491,5 @@ function collectGitHubBoundary(repoRoot, options = {}) {
         }
     };
 }
-export { collectGitHubBoundary, collectGitHubObjects, collectLocalObjects, fetchRestCollection, projectGitHubItem, projectGitHubTimelineItem, resolveGitHubRepository };
+export { collectGitHubBoundary, projectGitHubItem, projectGitHubTimelineItem, resolveGitHubRepository };
 //# sourceMappingURL=sources.js.map

package/dist/lib/render.js

@@ -47,18 +47,6 @@ function containsPlaceholders(src) {
     const content = fs.readFileSync(src, 'utf8');
     return content.includes('{{project}}') || content.includes('{{org}}');
 }
-function variantExt(relativePath) {
-    return path.extname(relativePath);
-}
-function variantBase(relativePath) {
-    const ext = variantExt(relativePath);
-    return relativePath.slice(0, -ext.length);
-}
-function withVariant(relativePath, variant) {
-    const ext = variantExt(relativePath);
-    const base = variantBase(relativePath);
-    return `${base}.${variant}${ext}`;
-}
 function stripVariant(relativePath, variant) {
     return relativePath.replace(new RegExp(`\\.${variant.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.`), '.');
 }

package/dist/lib/run/index.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { loadServerConfig } from '../server/config.js';
 import { resolveSandboxTarget } from '../sandbox/workspace-identity.js';
 import { createRunId, runInSandbox } from '../sandbox/capture.js';
-import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.js';
+import { normalizeShortIdInput } from '../task/short-id.js';
 import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.js';
 import { getSkillRunSpec } from './skills.js';
@@ -72,11 +72,23 @@ function extractHostOptions(args) {
     }
     return { positionals, forwarded, skill, taskRef, tui, recreate };
 }
+function parseCreateTaskArgs(skill, options) {
+    const { taskRef, recreate, positionals, forwarded, tui } = options;
+    if (taskRef !== null)
+        throw new Error("create-task does not accept '--task'");
+    if (recreate)
+        throw new Error('--recreate is only valid for sandbox task runs');
+    const createArgs = [...positionals, ...forwarded];
+    if (createArgs.length === 0)
+        throw new Error('create-task requires a description');
+    return { skill, taskRef: null, args: createArgs, tui };
+}
 export function parseRunArgs(args) {
     if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
         throw new Error(USAGE);
     }
-    const { positionals, forwarded, skill, taskRef, tui, recreate } = extractHostOptions(args);
+    const options = extractHostOptions(args);
+    const { positionals, forwarded, skill, taskRef, tui, recreate } = options;
     if (!skill)
         throw new Error("option '--skill' is required");
     const spec = getSkillRunSpec(skill);
@@ -87,14 +99,7 @@ export function parseRunArgs(args) {
         throw new Error(`Unsupported run route '${routeSelector}'`);
     }
     if (spec.kind === 'create') {
-        if (taskRef !== null)
-            throw new Error("create-task does not accept '--task'");
-        if (recreate)
-            throw new Error('--recreate is only valid for sandbox task runs');
-        const createArgs = [...positionals, ...forwarded];
-        if (createArgs.length === 0)
-            throw new Error('create-task requires a description');
-        return { skill, taskRef: null, args: createArgs, tui };
+        return parseCreateTaskArgs(skill, options);
     }
     if (positionals.length > 0) {
         throw new Error('ai run requires --skill and --task; positional host arguments are not supported');

package/dist/lib/run/skills.js

@@ -23,7 +23,4 @@ export function getSkillRunSpec(skill) {
     }
     return null;
 }
-export function allowedSkillNames() {
-    return ['create-task', ...TASK_SKILLS].sort();
-}
 //# sourceMappingURL=skills.js.map