@skrr-ai/cli 0.1.45 → 0.1.47

package/dist/commands/spaces/members/add.js

@@ -45,6 +45,7 @@ class SpacesMembersAdd extends base_command_1.BaseCommand {
         '<%= config.bin %> spaces members add <space-id> --user <user-id>',
         '<%= config.bin %> spaces members add <space-id> --agent <agent-id> --role editor',
         '<%= config.bin %> spaces members add <space-id> --agent <agent-id> --brief "Owns QA tasks"',
+        '<%= config.bin %> spaces members add <space-id> --agent <agent-id> --expertise browser --expertise frontend',
         '<%= config.bin %> spaces members add <space-id> --user <user-id> --agent <agent-id> --json',
     ];
     static args = {
@@ -67,6 +68,10 @@ class SpacesMembersAdd extends base_command_1.BaseCommand {
         }),
         brief: core_1.Flags.string({ description: 'Member brief to save for every added principal' }),
         'brief-file': core_1.Flags.string({ description: 'Path to a markdown/text brief file' }),
+        expertise: core_1.Flags.string({
+            description: 'Domain label the added members are best suited for (repeatable, ≤20 items, ≤40 chars each)',
+            multiple: true,
+        }),
     };
     async run() {
         this.requireAuth();
@@ -108,19 +113,22 @@ class SpacesMembersAdd extends base_command_1.BaseCommand {
                 public: Boolean(current.public),
                 publicAccessRoleId: current.publicAccessRoleId,
             });
-            if (brief && brief.trim().length > 0) {
+            const expertise = flags.expertise;
+            if ((brief && brief.trim().length > 0) || (expertise && expertise.length > 0)) {
                 const saves = [
                     ...userIds.map((principalId) => data_provider_1.dataService.upsertSpaceBrief({
                         spaceId: args.id,
                         principalType: 'user',
                         principalId,
-                        content: brief,
+                        content: brief && brief.trim().length > 0 ? brief : undefined,
+                        expertise,
                     })),
                     ...agentIds.map((principalId) => data_provider_1.dataService.upsertSpaceBrief({
                         spaceId: args.id,
                         principalType: 'agent',
                         principalId,
-                        content: brief,
+                        content: brief && brief.trim().length > 0 ? brief : undefined,
+                        expertise,
                     })),
                 ];
                 await Promise.all(saves);

package/dist/commands/spaces/members/list.js

@@ -22,8 +22,10 @@ class SpacesMembersList extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(SpacesMembersList);
         let response;
+        let briefs = [];
         try {
             response = await data_provider_1.dataService.getResourcePermissions(data_provider_1.ResourceType.SPACE, args.id);
+            briefs = (await data_provider_1.dataService.listSpaceBriefs(args.id).catch(() => [])).filter((b) => Array.isArray(b.expertise) && b.expertise.length > 0);
         }
         catch (err) {
             this.handleApiError(err);
@@ -41,14 +43,23 @@ class SpacesMembersList extends base_command_1.BaseCommand {
             type: String(p.type ?? '-'),
             name: String(p.name ?? p.email ?? '-'),
             role: (0, space_members_1.spaceRoleLabel)(String(p.accessRoleId ?? '')),
+            expertise: expertiseForPrincipal(briefs, p),
             id: (0, space_members_1.principalIdForDisplay)(p),
         }));
         (0, format_1.renderTable)(rows, [
             { key: 'type', header: 'TYPE' },
             { key: 'name', header: 'NAME', maxWidth: 36 },
             { key: 'role', header: 'ROLE' },
+            { key: 'expertise', header: 'EXPERTISE', maxWidth: 32 },
             { key: 'id', header: 'ID', verbatim: true },
         ], (line) => this.log(line));
     }
 }
 exports.default = SpacesMembersList;
+/** Brief principalId can be an agent UUID or a Mongo _id; match against both. */
+function expertiseForPrincipal(briefs, principal) {
+    const type = String(principal.type ?? '').toLowerCase();
+    const ids = new Set([principal.id, principal.idOnTheSource].filter((v) => v !== undefined).map(String));
+    const brief = briefs.find((b) => String(b.principalType ?? '').toLowerCase() === type && ids.has(String(b.principalId ?? '')));
+    return brief ? brief.expertise.join(', ') : '-';
+}

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

@@ -34,8 +34,17 @@ export default class TasksAssign extends BaseCommand {
         'repair-release-pins': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'execution-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         list: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        suggest: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     private renderMembers;
+    /**
+     * `--suggest`: a deterministic LOOKUP, not a routing decision. Declared
+     * member expertise is intersected with the task's tags (strong match) and
+     * its title/description text (weak match); the caller still chooses the
+     * assignee. This mirrors how the contract stays advisory everywhere else —
+     * the data is shown, the judgment stays with whoever is assigning.
+     */
+    private renderSuggestions;
 }

package/dist/commands/tasks/assign.js

@@ -6,6 +6,7 @@ const base_command_1 = require("../../base-command");
 const task_resolver_1 = require("../../lib/task-resolver");
 const web_url_1 = require("../../lib/web-url");
 const assignee_resolver_1 = require("../../lib/assignee-resolver");
+const format_1 = require("../../lib/format");
 const tasks_1 = require("../../lib/tasks");
 /**
  * A first-class `assign` verb.
@@ -37,6 +38,7 @@ class TasksAssign extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks assign <task-id> frank --replace',
         '<%= config.bin %> tasks assign <task-id> frank --remove',
         '<%= config.bin %> tasks assign <task-id> --list',
+        '<%= config.bin %> tasks assign <task-id> --suggest',
     ];
     static args = {
         id: core_1.Args.string({
@@ -76,6 +78,10 @@ class TasksAssign extends base_command_1.BaseCommand {
         list: core_1.Flags.boolean({
             description: "List the task's space members and exit (your own unshared agents can also be assigned, by id)",
         }),
+        suggest: core_1.Flags.boolean({
+            description: "Advisory lookup: list space members whose declared expertise intersects this task's tags " +
+                '(or whose expertise appears in the task text). Suggests only — never assigns.',
+        }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
     async run() {
@@ -105,7 +111,7 @@ class TasksAssign extends base_command_1.BaseCommand {
         }
         const personQueries = [...(args.person ? [args.person] : []), ...(flags.person ?? [])];
         const agentQueries = flags.agent ?? [];
-        if (!flags.list && personQueries.length === 0 && agentQueries.length === 0) {
+        if (!flags.list && !flags.suggest && personQueries.length === 0 && agentQueries.length === 0) {
             // Positional order is `<task-id> <person>`. Inside a task runtime the
             // task id is implicit, so a single positional (`skrr tasks assign frank`)
             // is silently eaten as the TASK id and the user sees a confusing
@@ -134,6 +140,10 @@ class TasksAssign extends base_command_1.BaseCommand {
             this.renderMembers(spaceId ? await this.loadSpaceMembers(spaceId) : [], spaceId, flags.json);
             return;
         }
+        if (flags.suggest) {
+            await this.renderSuggestions(taskRecord, spaceId, flags.json);
+            return;
+        }
         const people = await this.resolveAssignees(personQueries, 'user', spaceId);
         const agents = await this.resolveAssignees(agentQueries, 'agent', spaceId);
         const userIds = people.ids;
@@ -228,5 +238,102 @@ class TasksAssign extends base_command_1.BaseCommand {
         this.log(`\nAgents (${agents.length}):`);
         this.log(agents.length ? (0, assignee_resolver_1.describeCandidates)(agents, 100) : '  (none)');
     }
+    /**
+     * `--suggest`: a deterministic LOOKUP, not a routing decision. Declared
+     * member expertise is intersected with the task's tags (strong match) and
+     * its title/description text (weak match); the caller still chooses the
+     * assignee. This mirrors how the contract stays advisory everywhere else —
+     * the data is shown, the judgment stays with whoever is assigning.
+     */
+    async renderSuggestions(task, spaceId, json) {
+        if (!spaceId) {
+            this.failWithCliError({
+                message: 'Task is not in a space — no member expertise to suggest from. ' +
+                    'Assign by raw id, or move the task into a space first.',
+                code: 'ASSIGN_NO_SPACE_CONTEXT',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let principals = [];
+        let briefs = [];
+        try {
+            const [perms, briefList] = await Promise.all([
+                data_provider_1.dataService.getResourcePermissions(data_provider_1.ResourceType.SPACE, spaceId),
+                data_provider_1.dataService.listSpaceBriefs(spaceId).catch(() => []),
+            ]);
+            principals = (perms.principals ?? []);
+            briefs = briefList;
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const members = (0, assignee_resolver_1.membersFromPrincipals)(principals);
+        // brief.principalId may be an agent UUID or a Mongo _id — resolve through
+        // the principal's raw id pair so either convention lands on the member.
+        const expertiseByMemberId = new Map();
+        for (const p of principals) {
+            const kind = String(p.type ?? '').toLowerCase();
+            const brief = briefs.find((b) => String(b.principalType ?? '').toLowerCase() === kind &&
+                [p.id, p.idOnTheSource]
+                    .filter(Boolean)
+                    .map(String)
+                    .includes(String(b.principalId ?? '')));
+            if (!brief || !Array.isArray(brief.expertise) || brief.expertise.length === 0)
+                continue;
+            const resolvedId = kind === 'agent' ? String(p.idOnTheSource ?? p.id ?? '') : String(p.id ?? '');
+            if (resolvedId)
+                expertiseByMemberId.set(resolvedId, brief.expertise);
+        }
+        const norm = (v) => String(v ?? '')
+            .trim()
+            .toLowerCase();
+        const taskTags = (Array.isArray(task.tags) ? task.tags : []).map(norm);
+        const taskText = `${task.title ?? ''}\n${task.description ?? ''}`;
+        const suggestions = (0, assignee_resolver_1.suggestMembersByExpertise)({
+            members,
+            expertiseByMemberId,
+            taskTags,
+            taskText,
+        });
+        if (json) {
+            this.log(JSON.stringify({
+                spaceId,
+                taskTags,
+                suggestions: suggestions.map((s) => ({
+                    kind: s.member.kind,
+                    id: s.member.id,
+                    name: s.member.name ?? s.member.email ?? null,
+                    matchedTags: s.matchedTags,
+                    matchedText: s.matchedText,
+                })),
+            }, null, 2));
+            return;
+        }
+        const ref = task.identifier ?? task.id;
+        if (suggestions.length === 0) {
+            this.log(`No member expertise matches ${ref}` +
+                (taskTags.length === 0
+                    ? ' (the task has no tags — tag tasks or declare expertise to make routing smarter)'
+                    : ` (tags: ${taskTags.join(', ')})`) +
+                '.');
+            return;
+        }
+        this.log(`Suggested assignees for ${ref}${taskTags.length ? ` (tags: ${taskTags.join(', ')})` : ''}:`);
+        (0, format_1.renderTable)(suggestions.map((s) => ({
+            kind: s.member.kind,
+            member: s.member.name || s.member.email || s.member.id,
+            tag: s.matchedTags.join(', ') || '-',
+            text: s.matchedText.join(', ') || '-',
+            id: s.member.id,
+        })), [
+            { key: 'kind', header: 'KIND' },
+            { key: 'member', header: 'MEMBER', maxWidth: 28 },
+            { key: 'tag', header: 'TAG MATCH', maxWidth: 32 },
+            { key: 'text', header: 'TEXT MATCH', maxWidth: 32 },
+            { key: 'id', header: 'ID', verbatim: true },
+        ], (line) => this.log(line));
+        this.log(`\nAdvisory only — assign with: ${this.config.bin} tasks assign ${ref} --agent <name>`);
+    }
 }
 exports.default = TasksAssign;

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

@@ -0,0 +1,32 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks fork` — race a second attempt at the same work (B8).
+ *
+ * The line against `tasks handover`: a handover CONTINUES the work once, from a
+ * finished run. A fork runs a SIBLING attempt from the same Resume Point while
+ * the original is still live — both in one `parallel.groupId`, neither
+ * canonical until `tasks promote` picks one.
+ *
+ * The shared-workspace hazard is the reason this is not a flag on handover. Two
+ * executors of the same target class can be writing one workspace, and the
+ * server refuses (`shared_workspace_ack_required`) until the caller says
+ * plainly that it knows. `--acknowledge-shared-workspace` is that sentence;
+ * it is deliberately long to type.
+ */
+export default class TasksFork extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        harness: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'from-run': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'acknowledge-shared-workspace': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/fork.js

@@ -0,0 +1,171 @@
+"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 code_handover_1 = require("../../lib/code-handover");
+const task_extras_1 = require("../../lib/task-extras");
+const task_resolver_1 = require("../../lib/task-resolver");
+/**
+ * `skrr tasks fork` — race a second attempt at the same work (B8).
+ *
+ * The line against `tasks handover`: a handover CONTINUES the work once, from a
+ * finished run. A fork runs a SIBLING attempt from the same Resume Point while
+ * the original is still live — both in one `parallel.groupId`, neither
+ * canonical until `tasks promote` picks one.
+ *
+ * The shared-workspace hazard is the reason this is not a flag on handover. Two
+ * executors of the same target class can be writing one workspace, and the
+ * server refuses (`shared_workspace_ack_required`) until the caller says
+ * plainly that it knows. `--acknowledge-shared-workspace` is that sentence;
+ * it is deliberately long to type.
+ */
+class TasksFork extends base_command_1.BaseCommand {
+    static description = 'Race a sibling run of a task from the same Resume Point (parallel attempt, B8)';
+    static examples = [
+        '<%= config.bin %> tasks fork <task-id> --to "Codex Agent"',
+        '<%= config.bin %> tasks fork <task-id> --to agent_abc --harness agent-worker',
+        '<%= config.bin %> tasks fork <task-id> --from-run <run-id> --acknowledge-shared-workspace',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Task ID; defaults to OVERSKY_SESSION_TASK_ID in task runtimes',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the {run, packet, groupId} response as JSON' }),
+        task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
+        to: core_1.Flags.string({
+            description: 'Agent for the branch — id or name. Default: the source run’s own agent.',
+        }),
+        harness: core_1.Flags.string({
+            description: 'Execution target for the branch. Default: the target agent’s own policy chain.',
+        }),
+        'from-run': core_1.Flags.string({
+            description: 'Run to branch from (default: the task’s most recent run)',
+        }),
+        reason: core_1.Flags.string({ description: 'Why a second attempt — recorded in the packet' }),
+        'acknowledge-shared-workspace': core_1.Flags.boolean({
+            description: 'Proceed when the branch resolves to the same execution-target class as the source, ' +
+                'where two executors can write one workspace. Required by the server in that case.',
+            default: false,
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksFork);
+        let taskIdentity;
+        try {
+            taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        }
+        catch (err) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(err);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+                details: { suggestion: failure.suggestion, context: failure.details },
+            });
+        }
+        const taskId = taskIdentity.id;
+        // The branch agent is OPTIONAL — a fork onto the same agent on a different
+        // target is the "try it on Codex too" case, and the server derives the
+        // agent from the source run when none is named.
+        let targetAgentId;
+        if (flags.to) {
+            let agents = [];
+            try {
+                const resp = await data_provider_1.dataService.listAgents({ requiredPermission: data_provider_1.PermissionBits.VIEW });
+                agents = (resp?.data ?? []).filter(Boolean);
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
+            const matched = (0, code_handover_1.matchAgent)(flags.to, agents);
+            if (matched.kind === 'none') {
+                this.error(`No agent matches "${flags.to}". Run \`${this.config.bin} agents list\` to see the agents you can use.`);
+            }
+            if (matched.kind === 'ambiguous') {
+                this.error(`"${flags.to}" matches ${matched.candidates.length} agents. Pass the agent id instead:\n` +
+                    matched.candidates.map((a) => `  ${a.id}  ${a.name ?? ''}`).join('\n'));
+            }
+            targetAgentId = matched.agent.id;
+        }
+        let sourceRunId = flags['from-run'] ?? '';
+        if (!sourceRunId) {
+            let runs = [];
+            try {
+                const resp = await data_provider_1.dataService.getTaskRuns(taskId);
+                runs = (resp?.data ?? []);
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
+            const latest = runs[0];
+            if (!latest) {
+                this.failWithCliError({
+                    message: `Task ${taskId} has no runs to fork from. Run \`${this.config.bin} tasks runs ${taskId}\` to see the ledger.`,
+                    code: 'FORK_NO_SOURCE_RUN',
+                    exit: 2,
+                    retryable: false,
+                });
+            }
+            sourceRunId = String(latest.runId ?? latest.id ?? '');
+        }
+        let result;
+        try {
+            result = await (0, task_extras_1.taskRunFork)(taskId, sourceRunId, {
+                ...(targetAgentId ? { targetAgentId } : {}),
+                ...(flags.harness ? { executionTargetRef: (0, task_extras_1.parseExecutionTargetRef)(flags.harness) } : {}),
+                ...(flags.reason ? { reason: flags.reason } : {}),
+                ...(flags['acknowledge-shared-workspace'] ? { acknowledgeSharedWorkspace: true } : {}),
+            });
+        }
+        catch (err) {
+            const refusal = (0, base_command_1.apiRefusal)(err);
+            if (refusal.code?.toLowerCase() === 'shared_workspace_ack_required') {
+                this.failWithCliError({
+                    message: (refusal.message ??
+                        'The branch resolves to the same execution-target class as the source.') +
+                        '\n  → two executors could write one workspace. Re-run with ' +
+                        '`--acknowledge-shared-workspace` if that is acceptable, or pass `--harness` ' +
+                        'to put the branch on a different target class.',
+                    code: refusal.code,
+                    exit: 3,
+                    retryable: false,
+                    details: refusal.body,
+                });
+            }
+            if (refusal.code?.toLowerCase() === 'target_not_assignee') {
+                this.failWithCliError({
+                    message: (refusal.message ?? `Agent ${flags.to} may not work this task.`) +
+                        `\n  → assign it first: \`${this.config.bin} tasks assign ${taskId} --agent "${flags.to}"\`, then re-run.`,
+                    code: refusal.code,
+                    exit: 3,
+                    retryable: false,
+                    details: refusal.body,
+                });
+            }
+            this.handleApiError(err, { subject: `Task ${taskId}` });
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const r = result;
+        const branch = r.run ?? {};
+        const branchRunId = String(branch.runId ?? branch.id ?? '?');
+        this.log(`Forked run ${sourceRunId} → branch ${branchRunId}`);
+        this.log(`Parallel group: ${r.groupId ?? '?'}`);
+        const notCarried = Array.isArray(r.packet?.notCarried)
+            ? r.packet.notCarried.map(String).filter(Boolean)
+            : [];
+        this.log(`Not carried: ${notCarried.length ? notCarried.join(', ') : '(nothing declared)'}`);
+        this.log(`Both runs are live and neither is canonical. Pick one with ` +
+            `\`${this.config.bin} tasks promote ${taskId} --run <run-id>\` — the losers are cancelled.`);
+    }
+}
+exports.default = TasksFork;

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

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Whether a run row is a legal handover source — exported for tests.
+ * `endedAt` is a defensive OR: a projection that stamps a terminal timestamp
+ * without a recognized status is still terminal.
+ */
+export declare function isHandoverSourceRun(run: Record<string, unknown>): boolean;
+export default class TasksHandover extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        harness: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'from-run': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}