@skrr-ai/cli 0.1.102 → 0.1.104

package/dist/lib/commitments.js

@@ -18,14 +18,17 @@ exports.cadenceLabel = cadenceLabel;
 exports.renderCommitmentList = renderCommitmentList;
 exports.extractStandstillFromCheck = extractStandstillFromCheck;
 exports.describeExecutorBlocked = describeExecutorBlocked;
+exports.withLiveAssessment = withLiveAssessment;
 exports.renderCommitmentSummary = renderCommitmentSummary;
 exports.describeWakeDecision = describeWakeDecision;
 exports.renderCheckList = renderCheckList;
 exports.renderCommitmentLedger = renderCommitmentLedger;
 exports.renderCommitmentTrace = renderCommitmentTrace;
+exports.renderProactivenessScorecard = renderProactivenessScorecard;
 exports.formatCommitmentCycles = formatCommitmentCycles;
 exports.formatCommitmentExplanation = formatCommitmentExplanation;
 exports.renderListPageHint = renderListPageHint;
+exports.describeObservationArtifacts = describeObservationArtifacts;
 exports.renderCommitmentObservations = renderCommitmentObservations;
 exports.renderCommitmentHypotheses = renderCommitmentHypotheses;
 exports.renderCommitmentLineage = renderCommitmentLineage;
@@ -134,6 +137,10 @@ exports.commitmentApi = {
      * swept, how stale that is, and the tally it last persisted. Aggregate only.
      */
     livenessSweep: () => data_provider_2.request.get('/api/commitments/liveness/sweep'),
+    /** One agent's Commitments, system roles included, each with its loop status. */
+    roster: (agentId) => data_provider_2.request.get((0, triggers_1.withQuery)('/api/commitments/roster', { agentId })),
+    /** Is this Commitment's loop installed and working. */
+    loopStatus: (id) => data_provider_2.request.get(`${base(id)}/loop-status`),
     manifest: (id) => data_provider_2.request.get(`${base(id)}/manifest`),
     import: (body) => data_provider_2.request.post('/api/commitments/import', body),
     fork: (id, body) => data_provider_2.request.post(`${base(id)}/fork`, body),
@@ -512,8 +519,10 @@ function normalizeWatchedSourceDeclarations(declarations) {
     const bySource = new Map();
     const normalized = [];
     for (const binding of declarations) {
-        if (!binding || typeof binding !== 'object' ||
-            !('source' in binding) || typeof binding.source !== 'string') {
+        if (!binding ||
+            typeof binding !== 'object' ||
+            !('source' in binding) ||
+            typeof binding.source !== 'string') {
             normalized.push(binding); // The API owns validation of the remaining DTO.
             continue;
         }
@@ -646,10 +655,33 @@ function describeEvidenceHealth(health, criteriaCount) {
         return `unevidenceable_criteria${detail} — the criteria below cannot be judged from what this commitment observes; rewrite them or attach a Measure`;
     }
     if (state === 'degraded_observability') {
-        return `degraded_observability${detail} — an evaluator could not run; this is a fault, not a criteria problem`;
+        return `degraded_observability${detail} — ${describeDegradedObservability(reasons)}`;
     }
     return `${state}${detail}`;
 }
+/**
+ * What a `degraded_observability` verdict actually says, from its reasons.
+ *
+ * The state is a catch-all on the server (anything that is not purely an
+ * authoring problem lands here), so the copy used to assert "an evaluator
+ * could not run; this is a fault" for every case — including a commitment
+ * whose first run had simply not reported yet (OSK-15989). Only the
+ * `*_evidence_unavailable` reasons say an evaluator could not run; the rest
+ * say which part of the reading was missing, and that is what this names.
+ */
+function describeDegradedObservability(reasons) {
+    const has = (reason) => reasons.includes(reason);
+    if (has('state_evidence_unavailable') || has('outcome_evidence_unavailable')) {
+        return 'an evaluator could not run; this is a fault, not a criteria problem';
+    }
+    if (has('access_issues') || has('source_warning_or_error') || has('no_healthy_source')) {
+        return 'not every configured source could be read on the last check (`skrr commitments doctor <id>` names the next step)';
+    }
+    if (has('evidence_stale')) {
+        return "the freshest evidence is older than this commitment's freshness expectation";
+    }
+    return 'the last check could not see everything it needs to judge this commitment';
+}
 /** Render an interval back as a compact human string. */
 function describeIntervalMs(ms) {
     if (!ms || !Number.isFinite(ms))
@@ -827,6 +859,20 @@ function describeExecutorBlocked(commitment) {
                 : reason || 'blocked';
     return `${label}${until ? ` until ${until}` : ''}`;
 }
+/**
+ * The commitment `show` should render: its stored contract, with the
+ * assessment replaced by the one the operating state recomputed for this read
+ * when the server sent one (OSK-15989). The stored `commitment.assessment` is
+ * what the LAST check wrote; while a run is in flight it can still say
+ * `blocked`, and printing it above "Agent is working" made the header
+ * contradict the rest of the page. `doctor` already reads the live one first.
+ */
+function withLiveAssessment(commitment, operatingState) {
+    const live = operatingState?.assessment;
+    if (!live || typeof live !== 'object')
+        return commitment;
+    return { ...commitment, assessment: live };
+}
 function renderCommitmentSummary(commitment, log, 
 /**
  * The most recent check, when the caller has one. Optional because pause /
@@ -1195,10 +1241,103 @@ function renderCommitmentTrace(trace, log) {
         { key: 'stop', header: 'STOPPED AT', maxWidth: 48 },
         { key: 'summary', header: 'SUMMARY', maxWidth: 72 },
     ], 'No trace events recorded.', log);
+    const scorecard = record(trace.proactiveness);
+    if (scorecard)
+        renderProactivenessScorecard(scorecard, log);
     if (trace.has_more === true && trace.next_cursor) {
         log(`More events are available; continue with --cursor ${text(trace.next_cursor)}.`);
     }
 }
+/*
+ * Display order and words for `workClassification.counts`. The names are owned
+ * by the API scorecard (`COMMITMENT_CHECK_WORK_CLASSIFICATIONS` in
+ * CommitmentProactivenessMetrics); an unknown name still prints, by its key.
+ */
+const WORK_CLASSIFICATION_LABELS = {
+    justified_source_change: 'source changed',
+    justified_time_boundary: 'review/deadline due',
+    justified_evidence: 'evidence refresh',
+    work_item: 'open work item',
+    instruction: 'instruction',
+    repeat_identical_evidence: 'REPEAT on identical evidence',
+    unknown_basis: 'basis not recorded',
+};
+const SCORECARD_METRICS = [
+    { key: 'justifiedDecisionRate', label: 'Justified work', kind: 'ratio' },
+    { key: 'repeatDecisionRate', label: 'Repeat decisions', kind: 'ratio' },
+    { key: 'duplicateInvestigationRate', label: 'Duplicate investigations', kind: 'ratio' },
+    { key: 'usefulActionYield', label: 'Useful action yield', kind: 'ratio' },
+    { key: 'notificationPrecision', label: 'Notification precision', kind: 'ratio' },
+    { key: 'taskClosureRate', label: 'Task closure', kind: 'ratio' },
+    { key: 'provenanceCompleteness', label: 'Provenance complete', kind: 'ratio' },
+    { key: 'materialDetectionLatencyMs', label: 'Detection latency p50', kind: 'latency' },
+    { key: 'evidenceFreshnessMs', label: 'Evidence age p50', kind: 'latency' },
+];
+function scorecardValue(value, kind) {
+    if (kind === 'ratio') {
+        return typeof value === 'number' && Number.isFinite(value)
+            ? `${Math.round(value * 100)}%`
+            : '-';
+    }
+    const p50 = record(value)?.p50;
+    if (typeof p50 !== 'number' || !Number.isFinite(p50))
+        return '-';
+    return p50 >= 60_000 ? `${Math.round(p50 / 60_000)}m` : `${Math.round(p50 / 1000)}s`;
+}
+/** The qualifier that keeps a number from claiming more than its samples can. */
+function scorecardQualifier(coverage) {
+    if (!coverage)
+        return '';
+    const samples = typeof coverage.samples === 'number' ? coverage.samples : null;
+    const parts = [];
+    if (samples !== null)
+        parts.push(`${samples} sample${samples === 1 ? '' : 's'}`);
+    if (coverage.reliability === 'no_samples')
+        return '(no samples)';
+    if (coverage.reliability === 'mostly_unknown_basis') {
+        parts.push(`ESTIMATE: ${text(coverage.unknownBasis, '?')} with no recorded basis`);
+    }
+    else if (typeof coverage.unknownBasis === 'number' && coverage.unknownBasis > 0) {
+        parts.push(`${coverage.unknownBasis} with no recorded basis`);
+    }
+    if (typeof coverage.partialObservation === 'number' && coverage.partialObservation > 0) {
+        parts.push(`${coverage.partialObservation} partial observation`);
+    }
+    if (coverage.partialWindow === true)
+        parts.push('partial page');
+    return parts.length ? `(${parts.join('; ')})` : '';
+}
+function renderProactivenessScorecard(scorecard, log) {
+    const coverage = record(scorecard.coverage);
+    const metrics = record(scorecard.metrics) || {};
+    const metricCoverage = record(scorecard.metricCoverage) || {};
+    log('');
+    log(coverage?.partialWindow === true || record(scorecard.window)?.partial === true
+        ? 'Proactiveness (this page only — not the whole window)'
+        : 'Proactiveness');
+    if (coverage) {
+        log(`  Checks: ${text(coverage.checks, '0')} read · ${text(coverage.decisioningChecks, '0')} decided work · ` +
+            `${text(coverage.quietChecks, '0')} quiet · ${text(coverage.dedupeSuppressedChecks, '0')} suppressed as duplicate`);
+    }
+    const counts = record(record(scorecard.workClassification)?.counts);
+    if (counts) {
+        const parts = Object.entries(counts)
+            .filter(([, value]) => typeof value === 'number' && value > 0)
+            .map(([key, value]) => `${WORK_CLASSIFICATION_LABELS[key] || key} ${value}`);
+        log(`  Why work was decided: ${parts.length ? parts.join(' · ') : 'no decisioning Checks'}`);
+    }
+    for (const metric of SCORECARD_METRICS) {
+        if (!(metric.key in metrics))
+            continue;
+        const qualifier = scorecardQualifier(record(metricCoverage[metric.key]));
+        log(`  ${metric.label.padEnd(26)} ${scorecardValue(metrics[metric.key], metric.kind).padStart(5)}` +
+            (qualifier ? `  ${qualifier}` : ''));
+    }
+    for (const note of Array.isArray(coverage?.notes) ? coverage.notes : []) {
+        if (typeof note === 'string' && note)
+            log(`  Note: ${note}`);
+    }
+}
 const CYCLE_GLYPH = {
     advanced: '✓',
     stopped: '●',
@@ -1225,7 +1364,12 @@ function cycleWake(cycle) {
 function cycleSummary(cycle) {
     if (cycle.outcome === 'stopped' && cycle.stop) {
         const { question, gate, reason, fix, detail } = cycle.stop;
-        return `${question}  ${reason || gate} — ${fix || detail || 'stopped'}`;
+        // A stopped cycle can still have moved something (the Check's own read, a task it
+        // made); say so, or the row reads as if nothing happened (OSK-15408).
+        const moved = cycle.advancementKinds?.length
+            ? ` (moved: ${cycle.advancementKinds.join(', ')})`
+            : '';
+        return `${question}  ${reason || gate} — ${fix || detail || 'stopped'}${moved}`;
     }
     if (cycle.outcome === 'advanced') {
         return cycle.advancementKinds?.length
@@ -1321,6 +1465,8 @@ function formatCycleLatency(cycle) {
     ];
 }
 const ANSWER_GLYPH = { yes: '✓', no: '✗', 'n/a': '–' };
+/** The mark `cycles` already gives a chosen quiet: the loop looked and decided to say nothing. */
+const QUIET_ANSWER_GLYPH = CYCLE_GLYPH.quiet;
 /** The six questions for the latest Cycle, the first ✗ carrying its fix. */
 function formatCommitmentExplanation(explanation) {
     const cycle = explanation.cycle;
@@ -1332,7 +1478,14 @@ function formatCommitmentExplanation(explanation) {
     if (cycle)
         lines.push(...formatCycleLatency(cycle));
     for (const answer of explanation.answers || []) {
-        lines.push(`  ${ANSWER_GLYPH[answer.answer] || '?'} ${answer.question}  ${answer.because}`);
+        // The answer a deliberate quiet stopped at is not a refusal: `cycles` marks
+        // that cycle ○, and a ✗ here would read as a gate (OSK-15403).
+        const glyph = explanation.verdict === 'quiet' &&
+            answer.answer === 'no' &&
+            answer.key === explanation.stoppedAt
+            ? QUIET_ANSWER_GLYPH
+            : ANSWER_GLYPH[answer.answer] || '?';
+        lines.push(`  ${glyph} ${answer.question}  ${answer.because}`);
         if (answer.fix)
             lines.push(`      Fix: ${answer.fix}`);
     }
@@ -1376,6 +1529,30 @@ function yesNo(value) {
         return 'no';
     return '-';
 }
+/**
+ * Whether a row's retained evidence can still be reopened (OSK-16125).
+ *
+ * The count alone read as evidence even when every path pointed into a
+ * worktree the daemon had already deleted. `retained` artifacts are git
+ * locators on the run's delivery commit; `ephemeral` ones cannot be counted
+ * on; `unconfirmed` are locators for a path the run did not change. Refs the
+ * server classified as none of these (URLs, hashes, legacy rows) count as
+ * `other`. `--json` carries each artifact's `ref`, `locator` and `originalRef`.
+ */
+function describeObservationArtifacts(artifacts) {
+    const list = Array.isArray(artifacts) ? artifacts : [];
+    if (list.length === 0)
+        return '-';
+    const counts = new Map();
+    for (const artifact of list) {
+        const availability = text(record(artifact)?.availability, 'other');
+        counts.set(availability, (counts.get(availability) || 0) + 1);
+    }
+    return ['retained', 'unconfirmed', 'ephemeral', 'other']
+        .filter((name) => counts.has(name))
+        .map((name) => `${counts.get(name)} ${name}`)
+        .join(', ');
+}
 function renderCommitmentObservations(response, log, options = {}) {
     const data = records(response.data);
     renderRows(data.map((item) => ({
@@ -1404,6 +1581,7 @@ function renderCommitmentObservations(response, log, options = {}) {
         declared: yesNo(item.declared),
         access: text(item.accessStatus),
         confidence: (0, format_1.formatCell)(item.confidence),
+        artifacts: describeObservationArtifacts(item.artifacts),
     })), [
         { key: 'at', header: 'OBSERVED', maxWidth: 24 },
         { key: 'recorded', header: 'RECORDED', maxWidth: 24 },
@@ -1419,6 +1597,7 @@ function renderCommitmentObservations(response, log, options = {}) {
         { key: 'declared', header: 'DECLARED', maxWidth: 9 },
         { key: 'access', header: 'ACCESS', maxWidth: 13 },
         { key: 'confidence', header: 'CONF', maxWidth: 6 },
+        { key: 'artifacts', header: 'ARTIFACTS', maxWidth: 36 },
     ], options.emptyMessage || 'No observations recorded.', log);
 }
 /** Human view for causal hypotheses. */

package/dist/lib/delegated-cli.d.ts

@@ -2,7 +2,29 @@ import { type ResolvedCredential } from '@skrr-ai/auth-core';
 export declare function isDelegatedCliSession(env?: Record<string, string | undefined>): boolean;
 /** Drop the memoized credential. Exported for tests. */
 export declare function resetDelegatedCliCredentialCache(): void;
-/** Fetch a full-permission CLI access token from the local daemon. */
+/**
+ * The daemon's delegated broker answered and could not mint, for a reason it
+ * named (OSK-12151). `retryable` says whether waiting can help: false when only
+ * a new daemon sign-in repairs it (DEVICE_PROOF_PIN_MISMATCH), and then
+ * `remedy` is the command to run.
+ */
+export declare class DelegatedCliUnavailableError extends Error {
+    readonly retryable: boolean;
+    readonly upstreamStatus?: number;
+    readonly upstreamCode?: string;
+    readonly upstreamReason?: string;
+    /** ISO time before which the daemon will not ask the server again. */
+    readonly retryAt?: string;
+    readonly remedy?: string;
+    constructor(message: string, fields: {
+        retryable: boolean;
+        upstreamStatus?: number;
+        upstreamCode?: string;
+        upstreamReason?: string;
+        retryAt?: string;
+        remedy?: string;
+    });
+}
 export declare function fetchDelegatedCliCredential(env?: Record<string, string | undefined>, options?: {
     forceRefresh?: boolean;
 }): Promise<ResolvedCredential | null>;

package/dist/lib/delegated-cli.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedCliUnavailableError = void 0;
 exports.isDelegatedCliSession = isDelegatedCliSession;
 exports.resetDelegatedCliCredentialCache = resetDelegatedCliCredentialCache;
 exports.fetchDelegatedCliCredential = fetchDelegatedCliCredential;
@@ -198,6 +199,50 @@ function composeUnreachableBrokerMessage(brokerUrl, err) {
         (code ? ` (${code})` : ''));
 }
 /** Fetch a full-permission CLI access token from the local daemon. */
+/**
+ * Upstream codes the SAME daemon credential will keep getting, so retrying is
+ * pointless and the repair is signing the daemon in again (OSK-15990). Mirrors
+ * the daemon's `CREDENTIAL_BOUND_CODES`; it is the fallback for a daemon that
+ * predates the `retryable` field on its 503.
+ */
+const SIGN_IN_BOUND_CODES = new Set([
+    'DEVICE_PROOF_PIN_MISMATCH',
+    'CI_TOKEN_REFUSED',
+    'SESSION_REVOKED',
+    'PRINCIPAL_UNRESOLVED',
+    'USER_ID_UNRESOLVED',
+]);
+function isSignInBoundCode(code) {
+    return typeof code === 'string' && SIGN_IN_BOUND_CODES.has(code);
+}
+/**
+ * The daemon's delegated broker answered and could not mint, for a reason it
+ * named (OSK-12151). `retryable` says whether waiting can help: false when only
+ * a new daemon sign-in repairs it (DEVICE_PROOF_PIN_MISMATCH), and then
+ * `remedy` is the command to run.
+ */
+class DelegatedCliUnavailableError extends Error {
+    retryable;
+    upstreamStatus;
+    upstreamCode;
+    upstreamReason;
+    /** ISO time before which the daemon will not ask the server again. */
+    retryAt;
+    remedy;
+    constructor(message, fields) {
+        super(message);
+        this.name = 'DelegatedCliUnavailableError';
+        this.retryable = fields.retryable;
+        this.upstreamStatus = fields.upstreamStatus;
+        this.upstreamCode = fields.upstreamCode;
+        this.upstreamReason = fields.upstreamReason;
+        this.retryAt = fields.retryAt;
+        this.remedy =
+            fields.remedy ??
+                (fields.retryable ? undefined : 'run `skrr daemon login` on the machine running the daemon');
+    }
+}
+exports.DelegatedCliUnavailableError = DelegatedCliUnavailableError;
 async function fetchDelegatedCliCredential(env = process.env, options = {}) {
     if (!isDelegatedCliSession(env))
         return null;
@@ -270,11 +315,23 @@ async function fetchDelegatedCliCredential(env = process.env, options = {}) {
                 ]
                     .filter(Boolean)
                     .join(' ');
-                // The daemon's `message` already names the refusal; fall back to the
-                // status and code when an older daemon sent none.
-                throw new Error(typeof body?.message === 'string' && body.message
+                // The daemon's `message` already names the refusal (and, from a
+                // daemon with OSK-16117, when to retry or what to run); fall back to
+                // the status and code when an older daemon sent none.
+                throw new DelegatedCliUnavailableError(typeof body?.message === 'string' && body.message
                     ? `the daemon's delegated CLI broker could not mint a credential: ${body.message}`
-                    : `the skrr server refused the daemon's request for this session's credential (${named}).`);
+                    : `the skrr server refused the daemon's request for this session's credential (${named}).`, {
+                    ...(typeof body?.upstreamStatus === 'number' ? { upstreamStatus: body.upstreamStatus } : {}),
+                    ...(typeof body?.upstreamCode === 'string' ? { upstreamCode: body.upstreamCode } : {}),
+                    ...(typeof body?.upstreamReason === 'string'
+                        ? { upstreamReason: body.upstreamReason }
+                        : {}),
+                    ...(typeof body?.retryAt === 'string' ? { retryAt: body.retryAt } : {}),
+                    ...(typeof body?.remedy === 'string' ? { remedy: body.remedy } : {}),
+                    // Only an explicit `false` from the daemon makes this terminal; an
+                    // older daemon sends nothing and keeps today's retryable answer.
+                    retryable: !(body?.retryable === false || isSignInBoundCode(body?.upstreamCode)),
+                });
             }
             if (res.status === 503 || body?.code === 'DELEGATED_CLI_CREDENTIAL_UNAVAILABLE') {
                 throw new Error(`the daemon's delegated CLI broker is alive but cannot mint a credential ` +

package/dist/lib/first-party-harness.d.ts

@@ -139,7 +139,7 @@ export declare function resolveEngine(env?: NodeJS.ProcessEnv): EngineResolution
  * Build the engine argv for a `skrr code` invocation.
  *
  * Exported and pure so the forwarding contract is unit-testable without an
- * oclif runtime or a real binary — the convention `buildOverskyLogsArgs` uses.
+ * oclif runtime or a real binary — the convention `buildDaemonLogsArgs` uses.
  *
  * `subcommand === null` means bare `skrr code`, which launches the interactive
  * TUI: the engine takes no subcommand for that, and passing one would put it

package/dist/lib/first-party-harness.js

@@ -266,7 +266,7 @@ function resolveEngine(env = process.env) {
  * Build the engine argv for a `skrr code` invocation.
  *
  * Exported and pure so the forwarding contract is unit-testable without an
- * oclif runtime or a real binary — the convention `buildOverskyLogsArgs` uses.
+ * oclif runtime or a real binary — the convention `buildDaemonLogsArgs` uses.
  *
  * `subcommand === null` means bare `skrr code`, which launches the interactive
  * TUI: the engine takes no subcommand for that, and passing one would put it

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

@@ -1,4 +1,17 @@
 import type { SessionTaskOperation } from './session-task-endpoints';
+/**
+ * The server's refusal when a session's run carries no Task at all — a
+ * Commitment, Routine or other autonomous run that is not a Task run. It is
+ * the ONE refusal that means "the session-scoped route does not apply here",
+ * not "you may not write": such a run legitimately writes the Tasks it created
+ * or was handed, through the generic `/api/tasks/:id/*` routes, where
+ * `resolveTaskActor` attributes the Agent from the run headers and the Task's
+ * own ACL decides. Every other refusal (`session_claim_*`, `task_edit_forbidden`,
+ * an unavailable claim check) still fails closed.
+ */
+export declare const SESSION_HAS_NO_TASK = "session_has_no_task";
+/** Test hook: forget what this process learned about bound Tasks. */
+export declare function resetSessionTaskWriteCache(): void;
 /**
  * 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

package/dist/lib/session-task-write.js

@@ -1,9 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_HAS_NO_TASK = void 0;
+exports.resetSessionTaskWriteCache = resetSessionTaskWriteCache;
 exports.sessionTaskWrite = sessionTaskWrite;
 const api_fetch_1 = require("./api-fetch");
 const credential_resolver_1 = require("./credential-resolver");
 const session_task_endpoints_1 = require("./session-task-endpoints");
+/**
+ * The server's refusal when a session's run carries no Task at all — a
+ * Commitment, Routine or other autonomous run that is not a Task run. It is
+ * the ONE refusal that means "the session-scoped route does not apply here",
+ * not "you may not write": such a run legitimately writes the Tasks it created
+ * or was handed, through the generic `/api/tasks/:id/*` routes, where
+ * `resolveTaskActor` attributes the Agent from the run headers and the Task's
+ * own ACL decides. Every other refusal (`session_claim_*`, `task_edit_forbidden`,
+ * an unavailable claim check) still fails closed.
+ */
+exports.SESSION_HAS_NO_TASK = 'session_has_no_task';
+/**
+ * Sessions this process has already learned have no bound Task. A run's Task
+ * binding is fixed when the run is admitted, so the answer cannot change for
+ * the life of the session; remembering it saves a refused GET on every write.
+ */
+const sessionsWithoutBoundTask = new Set();
+/** Test hook: forget what this process learned about bound Tasks. */
+function resetSessionTaskWriteCache() {
+    sessionsWithoutBoundTask.clear();
+}
+/** The refusal reason of a 403 `ApiFetchError` (`{ ok:false, reason }` body). */
+function refusalReason(err) {
+    if (!err || typeof err !== 'object')
+        return undefined;
+    const { status, code, body } = err;
+    if (status !== 403)
+        return undefined;
+    if (typeof code === 'string' && code)
+        return code;
+    if (typeof body !== 'string' || !body)
+        return undefined;
+    try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed.reason === 'string')
+            return parsed.reason;
+        if (typeof parsed.code === 'string')
+            return parsed.code;
+    }
+    catch {
+        /* non-JSON body */
+    }
+    return undefined;
+}
 /**
  * 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
@@ -21,14 +67,28 @@ async function sessionTaskWrite(operation, requestedTask, env = process.env) {
             code: 'SESSION_TASK_CREDENTIAL_MISSING',
         });
     }
+    // A run with no bound Task (e.g. a Commitment run) has no session-scoped
+    // Task surface; its writes take the generic routes (OSK-16124).
+    if (sessionsWithoutBoundTask.has(sessionId))
+        return null;
     const prefix = `/api/agentic/sessions/${encodeURIComponent(sessionId)}`;
     // A scoped endpoint derives its Task and ignores a caller's Task id. Check
     // the requested coordinate first, so naming a sibling cannot quietly finish
     // the bound Task instead. The server independently rechecks the live binding
     // and checkout when committing the write.
-    const bound = await (0, api_fetch_1.apiFetch)(`${prefix}/task`, {
-        credential,
-    });
+    let bound;
+    try {
+        bound = await (0, api_fetch_1.apiFetch)(`${prefix}/task`, {
+            credential,
+        });
+    }
+    catch (err) {
+        if (refusalReason(err) === exports.SESSION_HAS_NO_TASK) {
+            sessionsWithoutBoundTask.add(sessionId);
+            return null;
+        }
+        throw err;
+    }
     if (!bound.id || !(0, session_task_endpoints_1.requestMatchesBoundTask)(bound, requestedTask)) {
         throw Object.assign(new Error(`This session is bound to task ${bound.identifier || bound.id || '?'} and cannot write the requested Task.`), {
             code: 'SESSION_SCOPE_TASK_MISMATCH',

package/dist/lib/triggers.d.ts

@@ -244,6 +244,8 @@ export declare function buildOnceConfigFromFlags(flags: Record<string, unknown>,
     allowNextRunAtAlias?: boolean;
 }): Record<string, unknown>;
 export declare function buildSelfScheduledConfigFromFlags(flags: Record<string, unknown>): Record<string, unknown>;
+export declare function buildEventConfigFromFlags(flags: Record<string, unknown>, filterValues: string[] | undefined): Record<string, unknown>;
+export declare function buildStochasticConfigFromFlags(flags: Record<string, unknown>): Record<string, unknown>;
 export declare function buildFormConfigFromFlags(flags: Record<string, unknown>): Record<string, unknown>;
 export declare function buildChatMessageConfigFromFlags(flags: Record<string, unknown>): Record<string, unknown>;
 export declare function parseExecutionReferences(referenceValues: string[] | undefined, referencesJson: string | undefined): Array<Record<string, unknown>> | undefined;
@@ -269,6 +271,30 @@ export declare function setDefined(target: Record<string, unknown>, values: Reco
 export declare function mergeObjectField(target: Record<string, unknown>, key: string, values: Record<string, unknown> | undefined): void;
 /** Attach only the discriminator subdocument owned by `kind`. */
 export declare function mergeTriggerKindConfig(target: Record<string, unknown>, kind: unknown, configs: Record<string, Record<string, unknown> | undefined>): void;
+/**
+ * The kinds whose config block each kind-specific flag fills. A flag that is not listed
+ * (--label, --mode, --prompt, --concurrency-key …) belongs to every kind.
+ *
+ * `mergeTriggerKindConfig` keeps only the block the chosen kind owns, so a flag for another
+ * kind used to be accepted and thrown away: `--max-fires-per-day 1` on an on_demand trigger
+ * stored no cap, `preflight` said `no_cap`, and the second fire still ran (OSK-15491).
+ * Declared beside the builders above, which are what read these flags.
+ */
+export declare const FLAG_OWNER_KINDS: Readonly<Record<string, readonly string[]>>;
+/**
+ * Refuse a kind-specific flag the trigger's kind cannot use, naming each one and the kinds that
+ * take it. Silence here is the defect: the caller believes a limit is in force.
+ */
+export declare function assertKindFlagsApply(kind: unknown, flags: Record<string, unknown>, options?: {
+    kindIsFixed?: boolean;
+}): void;
+/**
+ * The sentence for a fire's `scheduledFire` report: what a MANUAL fire skipped that a scheduled
+ * one would not. A manual fire is exempt from the enabled gate, the working/quiet-hours overlay and
+ * the autonomy ladder, so on its own it certifies nothing about whether the trigger will ever fire
+ * by itself (OSK-15492). Absent when the server reported nothing to say.
+ */
+export declare function describeScheduledFire(result: Record<string, unknown>): string | undefined;
 export declare function withQuery(path: string, params: Record<string, string | number | boolean | string[] | undefined>): string;
 /**
  * Build the universal-engine scope block for an agent-owned trigger.