@skrr-ai/cli 0.1.36 → 0.1.37

package/dist/lib/label-scope.js

@@ -2,7 +2,7 @@
 /**
  * Shared plumbing for the unified label commands (`skrr labels …`).
  *
- * Labels are anchored to exactly one scope — a user, a space, or a workspace —
+ * Labels are anchored to exactly one scope — a user or a workspace —
  * via the `(scope, scopeId)` pair. That pair is simultaneously the uniqueness
  * key and the permission boundary server-side (see
  * `api/server/services/Labels/LabelService.js`), so every label command has to
@@ -16,7 +16,7 @@ exports.normalizeLabelColor = normalizeLabelColor;
 exports.resolveLabelScope = resolveLabelScope;
 exports.resolveApplicableTo = resolveApplicableTo;
 const core_1 = require("@oclif/core");
-exports.LABEL_SCOPES = ['user', 'space', 'workspace'];
+exports.LABEL_SCOPES = ['user', 'workspace'];
 exports.LABEL_APPLICABLE = ['task', 'space', 'goal', 'routine'];
 /**
  * The server stores colors as bare 6-hex (`api/server/routes/labels.js` Zod is
@@ -44,7 +44,7 @@ exports.labelScopeFlags = {
 function resolveLabelScope(flags) {
     const scope = (flags.scope ?? 'user');
     const scopeId = flags['scope-id'];
-    if ((scope === 'space' || scope === 'workspace') && !scopeId) {
+    if (scope === 'workspace' && !scopeId) {
         throw new Error(`--scope-id is required for --scope ${scope}.`);
     }
     if (scope === 'user' && scopeId) {

package/dist/lib/task-closure.d.ts

@@ -0,0 +1,32 @@
+import type { TaskClosureEvaluation } from '@skrr-ai/data-provider';
+/**
+ * Render "where does this Task actually stand" for every surface that should
+ * say it.
+ *
+ * ONE renderer, because the failure this exists to fix was several surfaces each
+ * asserting a closure state none of them had checked: `tasks result submit`
+ * printed a hard-coded "it is ready for review", the server wrote a
+ * `ready_for_review` Update to match, and the managed instructions told the
+ * agent to read a status the response did not carry. Three confident voices,
+ * one unchecked claim.
+ *
+ * So the rule here is narrow and absolute: this function says only what the
+ * evaluation says. If the evaluation is absent or could not run, it says THAT —
+ * it never falls back to an optimistic sentence, because the optimistic sentence
+ * is the bug.
+ */
+export type ClosureLike = TaskClosureEvaluation | {
+    unavailable: true;
+    reason?: string;
+} | undefined;
+/**
+ * The full account, for the moment a caller has just written something and is
+ * deciding what to do next.
+ *
+ * Every unmet Expectation is NAMED. The ids alone (`e1`, `e2`) are what the
+ * gate's own details carried for a while, and they are unusable on their own —
+ * the whole point is to be able to act without a second lookup.
+ */
+export declare function closureReport(closure: ClosureLike): string[];
+/** `met (agent)` vs `met (you)` — whose judgement settled it, never hidden. */
+export declare function describeAssessor(kind: string | null | undefined): string;

package/dist/lib/task-closure.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closureReport = closureReport;
+exports.describeAssessor = describeAssessor;
+function isUnavailable(closure) {
+    return Boolean(closure && closure.unavailable);
+}
+const SHORT_BLOCKER = {
+    TASK_RESULT_REQUIRED: 'no Result submitted',
+    TASK_CURRENT_RESULT_MISSING: 'the current Result does not resolve',
+    TASK_RESULT_SPEC_VERSION_MISMATCH: 'the Result answers an older specification',
+    TASK_RESULT_CHANGES_REQUESTED: 'a reviewer requested changes',
+    TASK_RESULT_REVIEW_REQUIRED: 'an independent accepted Review is required',
+};
+/**
+ * The full account, for the moment a caller has just written something and is
+ * deciding what to do next.
+ *
+ * Every unmet Expectation is NAMED. The ids alone (`e1`, `e2`) are what the
+ * gate's own details carried for a while, and they are unusable on their own —
+ * the whole point is to be able to act without a second lookup.
+ */
+function closureReport(closure) {
+    if (!closure)
+        return ['Closure state: not reported by this call.'];
+    if (isUnavailable(closure)) {
+        return [
+            'Closure state could not be evaluated. That is a statement about this read,',
+            'not about the work — run `skrr tasks expectations <task-id>` to ask directly.',
+        ];
+    }
+    const lines = [];
+    const exp = closure.expectations;
+    /*
+     * The degraded note comes FIRST, and before the closable shortcut.
+     *
+     * An unreadable assessment ledger makes the gate fail OPEN — deliberately, so
+     * a Mongo blip cannot create a Task nothing can close — which means `closable`
+     * can be true precisely because a check did not run. Reporting only "nothing
+     * is outstanding" there would launder an infrastructure failure into a clean
+     * bill of health, which is the same class of silence this whole file exists to
+     * remove.
+     */
+    if (exp?.degraded === 'assessments_unreadable' || closure.degraded === 'assessments_unreadable') {
+        lines.push('Expectation assessments could not be read; that check was skipped, not passed.');
+    }
+    if (closure.closable) {
+        lines.push('Nothing is outstanding — this Task can close.');
+        return lines;
+    }
+    if (exp && exp.total > 0) {
+        /*
+         * "Settled," not "met" — a waived Expectation was judged no longer owed,
+         * which is a different fact from done. The count names waivers when any
+         * exist so a scope change never reads as completed work.
+         */
+        const settled = exp.settledCount ?? exp.settled?.length ?? exp.met;
+        const waivedNote = exp.waived ? ` (${exp.waived} waived)` : '';
+        lines.push(`Expectations: ${settled} of ${exp.total} settled${waivedNote}.`);
+        for (const row of exp.unmet) {
+            lines.push(`  ${row.id}  ${truncate(row.sentence || row.text || '(no text)', 76)}`);
+        }
+    }
+    for (const blocker of closure.blockers) {
+        if (blocker.code === 'TASK_EXPECTATIONS_NOT_MET')
+            continue;
+        lines.push(SHORT_BLOCKER[blocker.code] ? capitalize(SHORT_BLOCKER[blocker.code]) + '.' : blocker.message);
+    }
+    if (exp && exp.unmet.length > 0) {
+        lines.push('');
+        lines.push('Settle each with `skrr tasks expectations assess <task-id> <expectation-id>');
+        lines.push('  --decision met|waived --reason "..."`, or review the whole space with');
+        lines.push('  `skrr tasks review-queue --space <space-id>`.');
+    }
+    /*
+     * Everything else is advisory — stamped onto `resolution.closure` if the
+     * Task closes over it. The one refusal left is an owner-declared required
+     * Review, and only for someone who is not the owner; when that blocker is
+     * present, say the narrower truth.
+     */
+    const reviewRequired = closure.blockers.some((b) => b.code === 'TASK_RESULT_REVIEW_REQUIRED');
+    lines.push('');
+    lines.push(reviewRequired
+        ? 'Only an accepted independent Review — or the Task owner closing directly — settles this. The rest is recorded on resolution.closure.'
+        : 'Closing anyway is allowed — all of this is recorded on resolution.closure.');
+    return lines;
+}
+/** `met (agent)` vs `met (you)` — whose judgement settled it, never hidden. */
+function describeAssessor(kind) {
+    if (kind === 'agent')
+        return 'agent';
+    if (kind === 'human')
+        return 'person';
+    if (kind === 'system')
+        return 'system';
+    if (kind === 'integration')
+        return 'integration';
+    return 'unattributed';
+}
+function truncate(value, max) {
+    const flat = value.replace(/\s+/g, ' ').trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}

package/dist/lib/task-lifecycle-output.d.ts

@@ -0,0 +1,14 @@
+import type { TaskLifecycleHistoryResponse, TaskLifecycleResponse, TaskLifecycleTransitionResponse } from '@skrr-ai/data-provider';
+/**
+ * Render the Task Lifecycle response — the projection, its stages in protocol
+ * order, and the transitions the waiting stage currently declares.
+ */
+export declare function renderTaskLifecycleSummary(response: TaskLifecycleResponse, log: (line: string) => void): void;
+/** Render the outcome of a lifecycle transition call. */
+export declare function renderLifecycleTransitionResult(response: TaskLifecycleTransitionResponse, log: (line: string) => void): void;
+/**
+ * Render the durable lifecycle event stream — every generation's transitions,
+ * gates and run events, newest first. `lifecycle show` answers where the Task
+ * IS; this answers how it got there.
+ */
+export declare function renderLifecycleHistory(response: TaskLifecycleHistoryResponse, log: (line: string) => void): void;

package/dist/lib/task-lifecycle-output.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTaskLifecycleSummary = renderTaskLifecycleSummary;
+exports.renderLifecycleTransitionResult = renderLifecycleTransitionResult;
+exports.renderLifecycleHistory = renderLifecycleHistory;
+/**
+ * Render the Task Lifecycle response — the projection, its stages in protocol
+ * order, and the transitions the waiting stage currently declares.
+ */
+function renderTaskLifecycleSummary(response, log) {
+    const lifecycle = response.lifecycle;
+    if (!lifecycle) {
+        log('No lifecycle is attached to this Task.');
+        log('Attach one: skrr tasks lifecycle attach <task-id> --pack finding');
+        return;
+    }
+    log(`Lifecycle: ${lifecycle.status} (v${lifecycle.version}, generation ${lifecycle.generation}, revision ${lifecycle.revision})` +
+        (lifecycle.packId ? ` — pack ${lifecycle.packId}` : ''));
+    if (response.run)
+        log(`Run: ${response.run.id} — ${response.run.status}`);
+    for (const stage of response.stages || []) {
+        const marker = stage.key === lifecycle.currentStageKey ? '>' : ' ';
+        const state = stage.status
+            ? ` — ${stage.status}${stage.outcome ? `/${stage.outcome}` : ''}`
+            : '';
+        log(`${marker} ${stage.label || stage.key}${state}`);
+    }
+    if (response.gate) {
+        log('');
+        log(`Closure gate: ${response.gate.message}`);
+    }
+    const transitions = response.allowedTransitions || [];
+    const waiting = response.stage?.waitingFor;
+    if (response.stage && transitions.length) {
+        log('');
+        log(`Stage "${response.stage.nodeKey}" is waiting${waiting?.nextActor ? ` on ${waiting.nextActor}` : ''}. Legal transitions:`);
+        for (const transition of transitions) {
+            const needs = [
+                ...(transition.requires?.fields || []).map((f) => `payload.${f}`),
+                transition.requires?.updateType ? `${transition.requires.updateType} update` : undefined,
+                transition.requires?.evidence
+                    ? `${transition.requires.evidence} evidence ref(s)`
+                    : undefined,
+                transition.requires?.deliverableRef ? 'deliverable ref' : undefined,
+            ].filter(Boolean);
+            log(`  ${transition.id} -> ${transition.outcome}${transition.label ? ` (${transition.label})` : ''}${needs.length ? ` — needs ${needs.join(', ')}` : ''}`);
+        }
+    }
+    if (response.pendingEffects?.length) {
+        log('');
+        log(`${response.pendingEffects.length} effect(s) pending repair:`);
+        for (const effect of response.pendingEffects) {
+            log(`  ${effect.kind}${effect.lastError ? ` — ${effect.lastError}` : ''}`);
+        }
+    }
+    if (lifecycle.statusDrift) {
+        log(`Status drift: stage expects ${lifecycle.statusDrift.expected}, Task shows ${lifecycle.statusDrift.actual}.`);
+    }
+}
+/** Render the outcome of a lifecycle transition call. */
+function renderLifecycleTransitionResult(response, log) {
+    log(`Transition ${response.status}${response.code ? ` (${response.code})` : ''}.`);
+    if (response.message)
+        log(response.message);
+    for (const effect of response.effects || []) {
+        log(`  effect ${effect.kind}: ${effect.status}${effect.ref ? ` -> ${effect.ref}` : ''}${effect.error ? ` — ${effect.error}` : ''}`);
+    }
+    if (response.gate)
+        log(`Gate: ${response.gate.message}`);
+    if (response.lifecycle) {
+        log(`Lifecycle: ${response.lifecycle.status}, stage ${response.lifecycle.currentStageKey ?? '—'}, revision ${response.lifecycle.revision}.`);
+    }
+}
+/**
+ * Render the durable lifecycle event stream — every generation's transitions,
+ * gates and run events, newest first. `lifecycle show` answers where the Task
+ * IS; this answers how it got there.
+ */
+function renderLifecycleHistory(response, log) {
+    if (!response.events.length) {
+        log('No lifecycle events recorded for this Task.');
+        return;
+    }
+    for (const event of response.events) {
+        const parts = [
+            event.at,
+            event.type,
+            event.generation !== undefined ? `gen ${event.generation}` : undefined,
+            event.transitionId,
+            event.status,
+            event.outcome,
+            event.code,
+        ].filter(Boolean);
+        log(parts.join('  '));
+        if (event.message)
+            log(`    ${event.message}`);
+    }
+    if (response.truncated) {
+        log(`— truncated at the event limit; re-query with a higher --limit or --before.`);
+    }
+}

package/dist/lib/tasks.d.ts

@@ -66,6 +66,9 @@ export type TaskCreateFlagValues = {
     tag?: string[];
     'label-id'?: string[];
     worktree?: boolean;
+    'lifecycle-definition'?: string;
+    'lifecycle-version'?: string;
+    'lifecycle-pack'?: string;
 };
 /**
  * Map the tri-state `--worktree` flag to the `executionIsolation` value.

package/dist/lib/tasks.js

@@ -241,6 +241,22 @@ function normalizeTaskCreateJsonAliases(body) {
     }
     return normalized;
 }
+/**
+ * Assemble the create-time lifecycle binding from its three flags. Returns
+ * undefined when none are set so `mergeDefined` never writes an empty object.
+ */
+function lifecycleBindingFromFlags(flags) {
+    const definitionId = flags['lifecycle-definition'];
+    const versionId = flags['lifecycle-version'];
+    const packId = flags['lifecycle-pack'];
+    if (!definitionId && !versionId && !packId)
+        return undefined;
+    return {
+        ...(definitionId ? { definitionId } : {}),
+        ...(versionId ? { versionId } : {}),
+        ...(packId ? { packId } : {}),
+    };
+}
 function buildTaskCreatePayload(body, flags = {}) {
     const payload = (0, prompt_1.mergeDefined)(normalizeTaskCreateJsonAliases(body), {
         templateId: flags.template,
@@ -275,6 +291,7 @@ function buildTaskCreatePayload(body, flags = {}) {
         // Worktree isolation opt-in. --worktree ⇒ 'ephemeral', --no-worktree ⇒
         // 'shared', omitted ⇒ undefined (inherit space policy / global default).
         executionIsolation: executionIsolationFromWorktreeFlag(flags.worktree),
+        lifecycle: lifecycleBindingFromFlags(flags),
     });
     applyDaemonSessionDefaults(payload);
     normalizeStringField(payload, 'externalKey', 300);
@@ -349,6 +366,20 @@ function validateTaskCreatePayload(payload) {
     if (payload.templateId !== undefined && !isBoundedString(payload.templateId, 1, 100)) {
         errors.push('templateId must be a non-empty string at most 100 characters');
     }
+    if (payload.lifecycle !== undefined) {
+        const binding = payload.lifecycle;
+        if (!binding || typeof binding !== 'object' || Array.isArray(binding)) {
+            errors.push('lifecycle must be an object with definitionId, versionId, or packId');
+        }
+        else {
+            if (!isNonEmptyString(binding.definitionId) && !isNonEmptyString(binding.packId)) {
+                errors.push('lifecycle requires a definitionId or a packId');
+            }
+            if (binding.versionId !== undefined && !isNonEmptyString(binding.definitionId)) {
+                errors.push('lifecycle.versionId requires lifecycle.definitionId');
+            }
+        }
+    }
     for (const field of [
         'parentId',
         'goalId',

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/harnessTrust.js

@@ -68,6 +68,10 @@ exports.HARNESS_TIERS = Object.freeze({
     'opencode-acp': 1,
     gemini: 1,
     'gemini-acp': 1,
+    // Cognition's own CLI (`devin acp`). Vendor first-party like claude/codex —
+    // its credential is Cognition's API key, delivered over the ACP
+    // `authenticate` RPC rather than env (see daemon backends/devin.ts).
+    devin: 1,
     ...Object.fromEntries((0, firstPartyHarness_js_1.firstPartyHarnessSpellings)().map((spelling) => [spelling, 1])),
     // --- Tier 2: reviewed open-source community harnesses ---
     goose: 2,

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/harnessTrust.js

@@ -62,6 +62,10 @@ export const HARNESS_TIERS = Object.freeze({
     'opencode-acp': 1,
     gemini: 1,
     'gemini-acp': 1,
+    // Cognition's own CLI (`devin acp`). Vendor first-party like claude/codex —
+    // its credential is Cognition's API key, delivered over the ACP
+    // `authenticate` RPC rather than env (see daemon backends/devin.ts).
+    devin: 1,
     ...Object.fromEntries(firstPartyHarnessSpellings().map((spelling) => [spelling, 1])),
     // --- Tier 2: reviewed open-source community harnesses ---
     goose: 2,

package/dist/node_modules/@skrr-ai/auth-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/auth-core",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {