@skrr-ai/cli 0.1.95 → 0.1.97

package/dist/lib/mailbox-human-command.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../base-command';
+/**
+ * Mailbox reads belong to the person operating the account. Check before
+ * BaseCommand.init can redeem a delegated credential or read stored auth;
+ * the API independently verifies the actual principal and workspace ACL.
+ */
+export declare abstract class MailboxHumanCommand extends BaseCommand {
+    init(): Promise<void>;
+    protected requireHumanMailboxAuth(): void;
+    private refuseAgentContext;
+}

package/dist/lib/mailbox-human-command.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailboxHumanCommand = void 0;
+const base_command_1 = require("../base-command");
+const harness_context_1 = require("./harness-context");
+/**
+ * Mailbox reads belong to the person operating the account. Check before
+ * BaseCommand.init can redeem a delegated credential or read stored auth;
+ * the API independently verifies the actual principal and workspace ACL.
+ */
+class MailboxHumanCommand extends base_command_1.BaseCommand {
+    async init() {
+        this.refuseAgentContext();
+        await super.init();
+    }
+    requireHumanMailboxAuth() {
+        this.refuseAgentContext();
+        this.requireAuth();
+    }
+    refuseAgentContext() {
+        if ((0, harness_context_1.isHarnessCliContext)() ||
+            this.credentialProvenance?.kind === 'agent-session' ||
+            this.credentialProvenance?.kind === 'daemon-delegated') {
+            this.failWithCliError({
+                message: 'Mailbox metadata is available only to a human operator. Run this command in your own terminal.',
+                code: 'MAILBOX_HUMAN_REQUIRED',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        if (this.credentialProvenance?.kind === 'daemon-handoff') {
+            this.failWithCliError({
+                message: 'Mailbox metadata requires a direct human CLI sign-in. Run `skrr login --device-code` in your own terminal to skip the daemon broker, then try again.',
+                code: 'MAILBOX_HUMAN_CLI_REQUIRED',
+                exit: 2,
+                retryable: false,
+            });
+        }
+    }
+}
+exports.MailboxHumanCommand = MailboxHumanCommand;

package/dist/lib/measures.d.ts

@@ -1,13 +1,32 @@
+/**
+ * measures.ts — client for numeric outcomes (`/api/measures/*`).
+ *
+ * Gap analysis 2026-07-28 §B5. A **Measure** is a number with a unit, a
+ * baseline, a direction, and a target — the thing that makes
+ * `$12,400/mo → $9,100/mo` storable. Before it, the only value signal was
+ * `estimatedValueMinutes`: one unit, an LLM self-estimate, and a confirmation
+ * endpoint with zero callers.
+ *
+ * `rollup` is computed server-side on every read, never stored, so it cannot go
+ * stale the way a denormalized `progress` column does.
+ */
+import { type MeasureReadingProvenance, type MeasureProvenanceRollup, type MeasureRevision } from '@skrr-ai/data-provider';
 export declare const MEASURE_UNITS: readonly ["usd", "usd_per_month", "usd_per_year", "count", "percent", "minutes", "hours", "days", "bytes", "requests", "ratio", "score", "custom"];
 export declare const MEASURE_DIRECTIONS: readonly ["decrease", "increase", "maintain"];
-export declare const MEASURE_OBSERVATION_SOURCES: readonly ["manual", "agent_reported", "integration", "computed"];
+/**
+ * What a caller may write. `integration` and `computed` are platform-only: the
+ * server answers 400 `measure_source_reserved`, so offering them here would
+ * advertise a provenance label nobody can assert.
+ */
+export declare const MEASURE_WRITABLE_SOURCES: readonly ["manual", "agent_reported"];
 export interface MeasureObservation {
     value: number;
     observedAt: string;
     source: string;
-    /** An agent_reported value is a CLAIM until a human confirms it. */
+    /** Retained legacy stamp; provenance carries credential attribution. */
     confirmed: boolean;
     confirmedAt?: string;
+    provenance?: MeasureReadingProvenance;
     evidence?: string;
     note?: string;
 }
@@ -25,6 +44,7 @@ export interface Measure {
     };
     status: string;
     observations: MeasureObservation[];
+    revisions?: MeasureRevision[];
     rollup: {
         latest: number | null;
         baseline: number | null;
@@ -35,6 +55,7 @@ export interface Measure {
         observationCount: number;
         confirmedCount: number;
         unitLabel: string;
+        provenance?: MeasureProvenanceRollup;
     };
 }
 export type MeasureRecordConfirmation = {
@@ -43,6 +64,11 @@ export type MeasureRecordConfirmation = {
 };
 /** Explain the server's confirmation policy at the point a reading is written. */
 export declare function recordConfirmationForSource(source: string): MeasureRecordConfirmation;
+export declare function recordConfirmationForObservation(observation?: MeasureObservation): {
+    status: string;
+    message: string;
+};
+export declare function latestSelfReportedObservation(measure: Measure): MeasureObservation | undefined;
 export declare const measureApi: {
     list: (path: string) => Promise<{
         measures: Measure[];

package/dist/lib/measures.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.measureApi = exports.MEASURE_OBSERVATION_SOURCES = exports.MEASURE_DIRECTIONS = exports.MEASURE_UNITS = void 0;
+exports.measureApi = exports.MEASURE_WRITABLE_SOURCES = exports.MEASURE_DIRECTIONS = exports.MEASURE_UNITS = void 0;
 exports.recordConfirmationForSource = recordConfirmationForSource;
+exports.recordConfirmationForObservation = recordConfirmationForObservation;
+exports.latestSelfReportedObservation = latestSelfReportedObservation;
 exports.renderMeasureList = renderMeasureList;
 /**
  * measures.ts — client for numeric outcomes (`/api/measures/*`).
@@ -33,25 +35,45 @@ exports.MEASURE_UNITS = [
     'custom',
 ];
 exports.MEASURE_DIRECTIONS = ['decrease', 'increase', 'maintain'];
-exports.MEASURE_OBSERVATION_SOURCES = [
-    'manual',
-    'agent_reported',
-    'integration',
-    'computed',
-];
+/**
+ * What a caller may write. `integration` and `computed` are platform-only: the
+ * server answers 400 `measure_source_reserved`, so offering them here would
+ * advertise a provenance label nobody can assert.
+ */
+exports.MEASURE_WRITABLE_SOURCES = ['manual', 'agent_reported'];
 /** Explain the server's confirmation policy at the point a reading is written. */
 function recordConfirmationForSource(source) {
     if (source === 'manual') {
         return {
             status: 'confirmed',
-            message: 'Confirmed as ground truth: a manual reading is an owner confirmation.',
+            message: 'Marked confirmed: the current API automatically confirms manual readings.',
         };
     }
     return {
         status: 'pending_confirmation',
-        message: 'Recorded as a claim — confirm it with `skrr measures confirm` before using it as ground truth.',
+        message: 'Recorded unconfirmed — review it with `skrr measures confirm`. Confirmation does not prove measurement or causation.',
     };
 }
+function recordConfirmationForObservation(observation) {
+    const provenance = observation?.provenance;
+    const level = provenance?.level;
+    let message = 'Before provenance tracking; confirmation attribution unavailable.';
+    if (provenance)
+        message = (0, data_provider_1.describeMeasureEvidence)(provenance.level, provenance.confirmedBy || provenance.recordedBy);
+    if (level === 'system_observed')
+        message = `Platform-observed; ${(0, data_provider_1.personConfirmedMeasureReading)(observation) ? 'person-confirmed' : 'not confirmed by a person'}. Confirmation does not prove units or causal savings.`;
+    return {
+        status: level === 'human_confirmed' || (0, data_provider_1.personConfirmedMeasureReading)(observation)
+            ? 'confirmed'
+            : 'pending_confirmation',
+        message,
+    };
+}
+function latestSelfReportedObservation(measure) {
+    return measure.observations
+        .filter((o) => (o.provenance ? o.provenance.level === 'self_reported' : !o.confirmed))
+        .sort((a, b) => Date.parse(b.observedAt) - Date.parse(a.observedAt))[0];
+}
 exports.measureApi = {
     list: (path) => data_provider_1.request.get(path),
     get: (id) => data_provider_1.request.get(`/api/measures/${id}`),
@@ -79,17 +101,19 @@ function renderMeasureList(rows, log) {
         target: fmt(r.rollup.target, r.rollup.unitLabel),
         // Direction is STORED, so this reports the committed direction rather
         // than inferring good/bad from the sign.
-        moving: r.rollup.improved === null ? '-' : r.rollup.improved ? 'right way' : 'wrong way',
-        // Ground truth vs claim, kept as separate numbers on purpose.
-        confirmed: `${r.rollup.confirmedCount}/${r.rollup.observationCount}`,
+        moving: `${r.rollup.improved === null ? '-' : r.rollup.improved ? 'right way' : 'wrong way'}${r.rollup.provenance?.latestLevel === 'self_reported' ? ' (self-reported)' : ''}`,
+        // Evidence attribution is separate from the retained legacy stamp count.
+        evidence: r.rollup.provenance
+            ? `${(0, data_provider_1.describeMeasureProvenanceCounts)(r.rollup.provenance.byLevel)}${r.rollup.provenance.unattributedCount ? `; ${r.rollup.provenance.unattributedCount} before provenance tracking` : ''}`
+            : 'Before provenance tracking',
     })), [
         { key: 'label', header: 'MEASURE', maxWidth: 28 },
         { key: 'latest', header: 'LATEST', maxWidth: 14 },
         { key: 'baseline', header: 'BASELINE', maxWidth: 14 },
         { key: 'delta', header: 'DELTA', maxWidth: 12 },
         { key: 'target', header: 'TARGET', maxWidth: 14 },
-        { key: 'moving', header: 'MOVING', maxWidth: 10 },
-        { key: 'confirmed', header: 'CONFIRMED', maxWidth: 10 },
+        { key: 'moving', header: 'MOVING', maxWidth: 30 },
+        { key: 'evidence', header: 'EVIDENCE', maxWidth: 60 },
         { key: 'id', header: 'ID', verbatim: true },
     ], log);
 }

package/dist/lib/message-intent.d.ts

@@ -1,6 +1,6 @@
 import { type ResolvedCredential } from '@skrr-ai/auth-core';
 import type { AgentMessageSequence, EntityEmbed } from '@skrr-ai/data-provider';
-export declare const CANONICAL_DESTINATION_KINDS: readonly ["app_owner_dm", "slack_owner_dm", "slack_channel"];
+export declare const CANONICAL_DESTINATION_KINDS: readonly ["app_owner_dm", "slack_owner_dm", "slack_channel", "agent_email"];
 export type CanonicalDestinationKind = (typeof CANONICAL_DESTINATION_KINDS)[number];
 export type CanonicalMessageDestination = {
     kind: 'app_owner_dm';
@@ -10,6 +10,10 @@ export type CanonicalMessageDestination = {
     kind: 'slack_channel';
     channelId: string;
     threadTs?: string;
+} | {
+    kind: 'agent_email';
+    recipients: string[];
+    subject: string;
 };
 /**
  * The durable, user-facing taxonomy for deliberate Agent Updates. Keep this
@@ -78,7 +82,7 @@ export type CanonicalMessageIntentRequest = {
 export type CanonicalMessageIntentResponse = {
     ok: boolean;
     intentId?: string;
-    status?: 'submitted' | 'held' | 'approval_required' | 'authorized' | 'dispatching' | 'delivered' | 'failed' | 'dropped' | 'expired' | 'cancelled' | 'duplicate' | 'queued_offline';
+    status?: 'submitted' | 'held' | 'approval_required' | 'authorized' | 'dispatching' | 'delivered' | 'accepted' | 'unknown' | 'refused' | 'failed' | 'dropped' | 'expired' | 'cancelled' | 'duplicate' | 'queued_offline';
     reason?: string;
     retryAfter?: string;
     retryable?: boolean;

package/dist/lib/message-intent.js

@@ -20,6 +20,7 @@ exports.CANONICAL_DESTINATION_KINDS = [
     'app_owner_dm',
     'slack_owner_dm',
     'slack_channel',
+    'agent_email',
 ];
 /**
  * The durable, user-facing taxonomy for deliberate Agent Updates. Keep this

package/dist/lib/northstars.js

@@ -215,7 +215,8 @@ function renderGovernance(status, log) {
         log(`Protected     ${g.protectedCommitmentIds.join(', ')}`);
     }
     const eb = status.executionBudget ?? {};
-    log(`Exec budget   runs/day ${eb.maxRunsPerDay ?? '—'} · concurrent ${eb.maxConcurrentRuns ?? '—'} · critical reserve ${eb.reserveWeightForCritical ?? '—'}`);
+    log(`Exec budget   action runs/day ${eb.maxRunsPerDay ?? '—'} · concurrent ${eb.maxConcurrentRuns ?? '—'} · critical reserve ${eb.reserveWeightForCritical ?? '—'}`);
+    log(`Observation runs/day ${eb.maxObservationRunsPerDay ?? '—'} · daily budgets reset at 00:00 UTC`);
     log('');
     log(`Review trigger ${status.reviewTrigger.scheduled ? 'scheduled' : 'manual'}  every ${humanMs(status.reviewTrigger.intervalMs)}  next ${shortDate(status.reviewTrigger.nextFireAt)}`);
     if (status.latestReview) {

package/dist/lib/proposal-decision-command.d.ts

@@ -0,0 +1,19 @@
+import type { ProposalDecision } from '@skrr-ai/data-provider';
+import { BaseCommand } from '../base-command';
+/** The caller supplies the revision from show/list. Fetching a NEW card just
+ * before an old decision would approve content the caller never reviewed. */
+export declare abstract class ProposalDecisionCommand extends BaseCommand {
+    static decision: ProposalDecision;
+    static args: {
+        kind: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        expected: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'reason-code': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        until: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/lib/proposal-decision-command.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposalDecisionCommand = void 0;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../base-command");
+const proposals_1 = require("./proposals");
+/** The caller supplies the revision from show/list. Fetching a NEW card just
+ * before an old decision would approve content the caller never reviewed. */
+class ProposalDecisionCommand extends base_command_1.BaseCommand {
+    static decision;
+    static args = {
+        kind: core_1.Args.string({ required: true, options: [...data_provider_1.PROPOSAL_KINDS], ignoreStdin: true }),
+        id: core_1.Args.string({ required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean(),
+        expected: core_1.Flags.string({
+            required: true,
+            description: 'Exact revision JSON from proposals show/list',
+        }),
+        reason: core_1.Flags.string(),
+        'reason-code': core_1.Flags.string({ options: [...data_provider_1.PROPOSAL_DISCARD_REASON_CODES] }),
+        until: core_1.Flags.string({ description: 'Snooze-until ISO timestamp' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(this.constructor);
+        let expected;
+        try {
+            expected = JSON.parse(flags.expected);
+        }
+        catch {
+            this.error('--expected must be revision JSON from the reviewed proposal.');
+        }
+        const decision = this.constructor.decision;
+        if (decision === 'snooze' && !flags.until)
+            this.error('Snooze requires --until.');
+        if (decision === 'snooze') {
+            const until = Date.parse(flags.until);
+            if (Number.isNaN(until))
+                this.error('--until must be an ISO timestamp.');
+            if (until < Date.now() + data_provider_1.PROPOSAL_SNOOZE_MIN_SECONDS * 1000)
+                this.error('--until must be at least a minute from now.');
+            if (until > Date.now() + data_provider_1.PROPOSAL_SNOOZE_MAX_DAYS * 86400000)
+                this.error(`--until may be at most ${data_provider_1.PROPOSAL_SNOOZE_MAX_DAYS} days ahead.`);
+        }
+        let result;
+        try {
+            result = await proposals_1.proposalApi.decide(args.kind, args.id, {
+                decision,
+                expected,
+                reason: flags.reason,
+                reasonCode: flags['reason-code'],
+                snoozedUntil: flags.until,
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        this.log(flags.json ? JSON.stringify(result, null, 2) : `Proposal ${decision} decision recorded.`);
+    }
+}
+exports.ProposalDecisionCommand = ProposalDecisionCommand;

package/dist/lib/proposals.d.ts

@@ -0,0 +1,8 @@
+import type { ProposalDecisionParams, ProposalDecisionResponse, ProposalKind, ProposalListParams, ProposalListResponse, ProposalView } from '@skrr-ai/data-provider';
+/** The unified, read-time proposal inbox. Decisions are routed by the server to
+ * each family's own writer; the CLI never writes a source row. */
+export declare const proposalApi: {
+    list(params?: ProposalListParams): Promise<ProposalListResponse>;
+    show(kind: ProposalKind, id: string): Promise<ProposalView>;
+    decide(kind: ProposalKind, id: string, input: ProposalDecisionParams): Promise<ProposalDecisionResponse>;
+};

package/dist/lib/proposals.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proposalApi = void 0;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const triggers_1 = require("./triggers");
+const MOUNT = '/api/proposals';
+/** The unified, read-time proposal inbox. Decisions are routed by the server to
+ * each family's own writer; the CLI never writes a source row. */
+exports.proposalApi = {
+    list(params = {}) {
+        return data_provider_1.request.get((0, triggers_1.withQuery)(MOUNT, { ...params }));
+    },
+    show(kind, id) {
+        return data_provider_1.request.get(`${MOUNT}/${encodeURIComponent(kind)}/${encodeURIComponent(id)}`);
+    },
+    decide(kind, id, input) {
+        return data_provider_1.request.post(`${MOUNT}/${encodeURIComponent(kind)}/${encodeURIComponent(id)}/decision`, {
+            ...input,
+            via: 'cli',
+        });
+    },
+};

package/dist/lib/roles.d.ts

@@ -1,4 +1,4 @@
-import type { InstalledRole, RolePlanPreview, RoleInstallation, AgentOperatingPlan } from '@skrr-ai/data-provider';
+import type { InstalledRole, RoleOperatingSpec, RolePlanPreview, RoleInstallation, AgentOperatingPlan } from '@skrr-ai/data-provider';
 export declare const roleBase: (agentId: string) => string;
 export declare const roleApi: {
     list: (id: string) => Promise<{
@@ -13,10 +13,10 @@ export declare const roleApi: {
             }>;
         };
     }>;
-    preview: (id: string, spec: unknown, contextBindings?: unknown) => Promise<RolePlanPreview>;
-    install: (id: string, preview: RolePlanPreview) => Promise<RoleInstallation>;
+    preview: (id: string, spec: unknown, contextBindings?: unknown, parameterValues?: unknown, endpointBindings?: unknown) => Promise<RolePlanPreview>;
+    install: (id: string, preview: RolePlanPreview, confirmRuleConflicts?: string[]) => Promise<RoleInstallation>;
     export: (id: string, key: string) => Promise<{
-        kind: "oversky.role-operating-spec";
+        kind: "role-operating-spec" | "oversky.role-operating-spec";
         schemaVersion: 1;
         key: string;
         revision: number;
@@ -49,11 +49,11 @@ export declare const roleApi: {
             successCriteria: {
                 id: string;
                 label: string;
-                evaluator?: "manual" | "metric" | "source_state" | "task_state" | "goal_state" | "llm_review" | undefined;
+                evaluator?: "manual" | "task_state" | "goal_state" | "metric" | "llm_review" | "source_state" | undefined;
                 config?: Record<string, unknown> | undefined;
             }[];
             sources: {
-                source: "space" | "tasks" | "email" | "goal" | "files" | "local" | "daemon" | "browser" | "conversations" | "memory" | "slack" | "github" | "messages" | "metrics" | "monitor" | "agent_initiatives" | "docs" | "documents" | "calendar" | "product_metrics" | "business_metrics" | "state_monitor" | "agent_run";
+                source: "space" | "tasks" | "email" | "goal" | "files" | "local" | "daemon" | "browser" | "conversations" | "slack" | "memory" | "github" | "messages" | "calendar" | "docs" | "metrics" | "agent_run" | "agent_initiatives" | "documents" | "product_metrics" | "business_metrics" | "state_monitor" | "monitor";
                 enabled: boolean;
                 config?: Record<string, unknown> | undefined;
             }[];
@@ -81,7 +81,47 @@ export declare const roleApi: {
                 roles: ("home" | "delivery" | "watch" | "advance")[];
             }[];
             directive?: string | undefined;
+            subject?: {
+                type: string;
+                externalKey: string;
+                label?: string | undefined;
+            } | undefined;
+            governance?: {
+                quietHours?: {
+                    enabled: boolean;
+                    start?: string | undefined;
+                    end?: string | undefined;
+                    timezone?: string | undefined;
+                } | undefined;
+                nudges?: {
+                    maxPerDay?: number | null | undefined;
+                    minIntervalMs?: number | undefined;
+                } | undefined;
+                attention?: {
+                    severityLoudness?: {
+                        low?: "standard" | "quiet" | "loud" | undefined;
+                        medium?: "standard" | "quiet" | "loud" | undefined;
+                        high?: "standard" | "quiet" | "loud" | undefined;
+                    } | undefined;
+                    escalation?: {
+                        minimumSeverity?: "low" | "medium" | "high" | undefined;
+                        channel?: "push" | "none" | "email" | "cli" | "app" | "slack" | undefined;
+                    } | undefined;
+                    noReply?: {
+                        enabled?: boolean | undefined;
+                        afterNudges?: number | undefined;
+                    } | undefined;
+                } | undefined;
+                proactiveMessaging?: {
+                    posture: "quiet" | "agent_discretion" | "first_material_blocker" | "high_visibility";
+                } | undefined;
+            } | undefined;
+            reports?: {
+                slot: string;
+                on: "completion" | "escalation" | "material_change" | "every_check";
+            }[] | undefined;
             deadlineAt?: string | undefined;
+            taskReviewPolicy?: "none" | "required" | undefined;
             freshness?: {
                 staleAfterMs?: number | undefined;
                 blockedAfterMs?: number | undefined;
@@ -90,9 +130,104 @@ export declare const roleApi: {
             evaluationPolicy?: Record<string, unknown> | undefined;
             learningPolicy?: Record<string, unknown> | undefined;
         }[];
+        rules?: ({
+            kind: "text_required";
+            text: string;
+            effect: "append";
+            id: string;
+            status: "active" | "proposed" | "retired";
+            reason?: string | undefined;
+            source?: {
+                kind: "owner" | "role_spec" | "correction";
+                ref?: {
+                    conversationId: string;
+                    messageId: string;
+                } | undefined;
+            } | undefined;
+            createdAt?: string | undefined;
+            createdBy?: string | undefined;
+        } | {
+            kind: "text_forbidden";
+            phrases: string[];
+            effect: "refuse" | "require_approval";
+            id: string;
+            status: "active" | "proposed" | "retired";
+            reason?: string | undefined;
+            source?: {
+                kind: "owner" | "role_spec" | "correction";
+                ref?: {
+                    conversationId: string;
+                    messageId: string;
+                } | undefined;
+            } | undefined;
+            createdAt?: string | undefined;
+            createdBy?: string | undefined;
+        })[] | undefined;
+        governance?: {
+            quietHours?: {
+                enabled: boolean;
+                start?: string | undefined;
+                end?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+            nudges?: {
+                maxPerDay?: number | null | undefined;
+                minIntervalMs?: number | undefined;
+            } | undefined;
+            attention?: {
+                severityLoudness?: {
+                    low?: "standard" | "quiet" | "loud" | undefined;
+                    medium?: "standard" | "quiet" | "loud" | undefined;
+                    high?: "standard" | "quiet" | "loud" | undefined;
+                } | undefined;
+                escalation?: {
+                    minimumSeverity?: "low" | "medium" | "high" | undefined;
+                    channel?: "push" | "none" | "email" | "cli" | "app" | "slack" | undefined;
+                } | undefined;
+                noReply?: {
+                    enabled?: boolean | undefined;
+                    afterNudges?: number | undefined;
+                } | undefined;
+            } | undefined;
+            proactiveMessaging?: {
+                posture: "quiet" | "agent_discretion" | "first_material_blocker" | "high_visibility";
+            } | undefined;
+        } | undefined;
+        parameters?: {
+            key: string;
+            label: string;
+            type: "string" | "number" | "boolean" | "enum" | "string_list";
+            required: boolean;
+            default?: unknown;
+            options?: string[] | undefined;
+            maxLength?: number | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+            maxItems?: number | undefined;
+        }[] | undefined;
+        endpointSlots?: {
+            key: string;
+            label: string;
+            required: boolean;
+            destinations: ("app_owner_dm" | "slack_owner_dm" | "slack_channel")[];
+        }[] | undefined;
     }>;
     withdraw: (id: string, key: string, expectedCompassVersion: number) => Promise<RoleInstallation>;
     plan: (id: string) => Promise<AgentOperatingPlan>;
+    capture: (id: string, input: {
+        key: string;
+        title: string;
+        compassId?: string;
+        commitmentIds: string[];
+    }) => Promise<{
+        spec: RoleOperatingSpec;
+        omitted: Array<{
+            responsibilityKey?: string;
+            field: string;
+            reason: string;
+        }>;
+        prerequisites: string[];
+    }>;
 };
 export declare function readRoleJson(file: string): unknown;
 export declare function assertRolePreview(value: unknown): asserts value is RolePlanPreview;

package/dist/lib/roles.js

@@ -9,23 +9,29 @@ const roleBase = (agentId) => `/api/agents/${encodeURIComponent(agentId)}`;
 exports.roleBase = roleBase;
 exports.roleApi = {
     list: (id) => data_provider_1.request.get(`${(0, exports.roleBase)(id)}/roles`),
-    preview: (id, spec, contextBindings = {}) => data_provider_1.request.post(`${(0, exports.roleBase)(id)}/roles/preview`, {
+    preview: (id, spec, contextBindings = {}, parameterValues = {}, endpointBindings = {}) => data_provider_1.request.post(`${(0, exports.roleBase)(id)}/roles/preview`, {
         spec,
         contextBindings,
+        parameterValues,
+        endpointBindings,
     }),
-    install: (id, preview) => data_provider_1.request.post(`${(0, exports.roleBase)(id)}/roles/install`, {
+    install: (id, preview, confirmRuleConflicts = []) => data_provider_1.request.post(`${(0, exports.roleBase)(id)}/roles/install`, {
         spec: preview.spec,
         fingerprint: preview.fingerprint,
         reviewFingerprint: preview.reviewFingerprint,
         expectedCompassVersion: preview.expectedCompassVersion,
         expectedVersions: preview.expectedVersions,
         contextBindings: preview.contextBindings || {},
+        parameterValues: preview.parameterValues || {},
+        endpointBindings: preview.endpointBindings || {},
+        ...(confirmRuleConflicts.length ? { confirmRuleConflicts } : {}),
     }),
     export: (id, key) => data_provider_1.request.get(`${(0, exports.roleBase)(id)}/roles/${encodeURIComponent(key)}/export`),
     withdraw: (id, key, expectedCompassVersion) => data_provider_1.request.post(`${(0, exports.roleBase)(id)}/roles/${encodeURIComponent(key)}/withdraw`, {
         expectedCompassVersion,
     }),
     plan: (id) => data_provider_1.request.get(`${(0, exports.roleBase)(id)}/operating-plan`),
+    capture: (id, input) => data_provider_1.request.post(`${(0, exports.roleBase)(id)}/roles/capture`, input),
 };
 function readRoleJson(file) {
     return JSON.parse((0, node_fs_1.readFileSync)(file, 'utf8'));

package/dist/lib/session-task-write.d.ts

@@ -0,0 +1,18 @@
+import type { SessionTaskOperation } from './session-task-endpoints';
+/**
+ * A canonical Task write must retain its authenticated session actor even if
+ * the daemon also grants the CLI a wide credential. The wide credential names
+ * its account, not the Agent that is executing this Task. Passing the trusted
+ * session credential explicitly makes apiFetch keep the server's bound actor.
+ * Human invocations continue through their ordinary Task endpoints.
+ */
+export declare function sessionTaskWrite(operation: Exclude<SessionTaskOperation, 'read'>, requestedTask: string, env?: Record<string, string | undefined>): Promise<{
+    path: string;
+    credential: import("@skrr-ai/auth-core/dist/esm/credentialResolver").ResolvedCredential;
+    taskId: string;
+    task: {
+        id?: string;
+        _id?: string;
+        identifier?: string;
+    } & Record<string, unknown>;
+} | null>;