@skrr-ai/cli 0.1.41 → 0.1.43

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

@@ -19,8 +19,10 @@
  * Every product-named value — the binary's file name, the engine home, the env
  * var names, the display name — is read from the identity module in
  * `@skrr-ai/auth-core` (`docs/architecture/skrr-code-identifier-rename-2026-09-13.md`).
- * The engine's file name has more than one spelling while a rename is in
- * flight, so resolution tries every spelling, canonical first, in each location.
+ * An installed engine is an ARTIFACT: one installed before a rename is still on
+ * disk under its old file name after that name stops being accepted anywhere, so
+ * resolution tries every artifact spelling (`firstPartyHarnessArtifactSpellings`),
+ * canonical first, in each location. That recognises a file; it admits no input.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -81,14 +83,15 @@ function engineHome(env = process.env) {
 /**
  * The user-level instruction root the engine owns.
  *
- * Read under the neutral variable first and its older name second
- * (`readFirstPartyHarnessEnv`). The older name is also the one the ENGINE reads,
- * which is why {@link engineOwnedEnv} hands the resolved value to the engine under
- * that name — otherwise the doctor would honour the neutral variable and the
- * engine would not.
+ * Read under the platform's neutral variable first, then under the variable the
+ * ENGINE itself reads (`FIRST_PARTY_HARNESS_ENGINE.env.home`). The second is not a
+ * legacy fallback: it is the engine's own name, the engine honours it whatever the
+ * platform does, and a CLI that ignored it would report one instruction root while
+ * the engine it launches used another. {@link engineOwnedEnv} closes the other
+ * direction, handing a neutral-variable value to the engine under its own name.
  */
 function engineInstructionHome(env = process.env) {
-    const configured = (0, auth_core_1.readFirstPartyHarnessEnv)(env, 'home').value;
+    const configured = (0, auth_core_1.readFirstPartyHarnessEnv)(env, 'home').value ?? engineHomeVariable(env);
     // Falls through to `engineHome()` rather than re-deriving `~/.skrr` — the two
     // describe the same root, and re-deriving it is what made them disagree under
     // `OVERSKY_CONFIG_DIR` (OSK-300).
@@ -100,6 +103,11 @@ function engineInstructionHome(env = process.env) {
         return node_path_1.default.join((0, node_os_1.homedir)(), configured.slice(2));
     return node_path_1.default.resolve(configured);
 }
+/** The engine's own home variable, trimmed; undefined when unset or blank. */
+function engineHomeVariable(env) {
+    const raw = env[auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.home];
+    return typeof raw === 'string' && raw.trim() !== '' ? raw.trim() : undefined;
+}
 /**
  * The managed install location for one spelling of the binary (canonical by
  * default) — where the daemon, the Desktop app, and
@@ -109,8 +117,9 @@ function managedEnginePath(env = process.env, provider = auth_core_1.FIRST_PARTY
     return (0, auth_core_1.firstPartyHarnessInstalledBinaryPath)(env, provider, process.platform);
 }
 /**
- * The same managed location under the PREVIOUS config root, for every spelling of
- * the binary and every engine home name, canonical first.
+ * The same managed location under the PREVIOUS config root, for every artifact
+ * spelling of the binary (former spellings included) and every engine home name,
+ * canonical first.
  *
  * The root moved `~/.oversky` → `~/.skrr` in the skrr rename, and an engine
  * installed before that is still on disk under the old one. `daemon/src/
@@ -120,7 +129,7 @@ function managedEnginePath(env = process.env, provider = auth_core_1.FIRST_PARTY
  *
  * The engine-home move (`migrateFirstPartyHarnessHome`) only ever works under the
  * CURRENT root, so nothing renames a binary here — which is why this list carries
- * every spelling rather than only the canonical one.
+ * every artifact spelling rather than only the canonical one.
  *
  * Empty when an explicit `OVERSKY_CONFIG_DIR` is set, matching the daemon: that
  * override names one root deliberately, and reaching past it to a hard-coded home
@@ -149,11 +158,13 @@ function fallbackPaths(exeName) {
     ];
 }
 /**
- * The file names a PATH directory may hold the engine under, canonical first.
- * Windows also accepts a `.cmd` shim, as a package manager may install one.
+ * The file names a PATH directory may hold the engine under, canonical first —
+ * every artifact spelling, since a standalone install made before a rename keeps
+ * its old name. Windows also accepts a `.cmd` shim, as a package manager may
+ * install one.
  */
 function pathExecutableNames(platform) {
-    return (0, auth_core_1.firstPartyHarnessSpellings)().flatMap((spelling) => platform === 'win32'
+    return (0, auth_core_1.firstPartyHarnessArtifactSpellings)().flatMap((spelling) => platform === 'win32'
         ? [(0, auth_core_1.firstPartyHarnessBinaryName)(spelling, platform), `${spelling}.cmd`]
         : [(0, auth_core_1.firstPartyHarnessBinaryName)(spelling, platform)]);
 }
@@ -176,12 +187,12 @@ function isExecutable(p) {
  * The env override is checked first and is absolute-only. A relative override
  * would resolve against the caller's cwd, which for an agent-invoked command is
  * attacker-influenced: a repo containing a file named like the engine could
- * hijack it. It is read under its neutral name first and its older name second.
+ * hijack it.
  *
  * **Order: env → managed → PATH → well-known (WL-6.2).** Within each location
- * every spelling of the binary is tried, canonical first — the daemon's order —
- * so an engine installed under an older name still resolves, and the canonical
- * one wins wherever both exist.
+ * every artifact spelling of the binary is tried, canonical first — the daemon's
+ * order — so an engine installed under an older or former name still resolves,
+ * and the canonical one wins wherever both exist.
  *
  * The managed location beating `PATH` is the load-bearing part, and it is a
  * deliberate reversal of the obvious ordering.
@@ -210,7 +221,7 @@ function resolveEngine(env = process.env) {
     const platform = process.platform;
     const override = (0, auth_core_1.readFirstPartyHarnessEnv)(env, 'path');
     if (override.value && override.name) {
-        const origin = { envName: override.name, legacyEnv: override.legacy };
+        const origin = { envName: override.name };
         const candidate = override.value;
         if (!node_path_1.default.isAbsolute(candidate))
             return { path: null, source: 'unresolved', ...origin };
@@ -218,7 +229,7 @@ function resolveEngine(env = process.env) {
             ? { path: candidate, source: 'env', ...origin }
             : { path: null, source: 'unresolved', ...origin };
     }
-    for (const spelling of (0, auth_core_1.firstPartyHarnessSpellings)()) {
+    for (const spelling of (0, auth_core_1.firstPartyHarnessArtifactSpellings)()) {
         const managed = managedEnginePath(env, spelling);
         if (isExecutable(managed))
             return { path: managed, source: 'managed' };
@@ -595,18 +606,19 @@ mode) {
  * `skrr code doctor` honour it while the engine it launches ignored it — two
  * answers to "where do my instructions live" from one command.
  *
- * Only when the value came from a name the engine does NOT read: a value set under
- * the engine's own name is inherited already, and rewriting it would only replace
- * the user's spelling of a path with ours. The resolved path is passed rather than
- * the raw value, so the engine and the doctor agree on `~` expansion too.
+ * Only when the neutral variable supplied the value: a value set only under the
+ * engine's own name is inherited already, and rewriting it would only replace the
+ * user's spelling of a path with ours. When both are set the neutral one wins, as
+ * it does in {@link engineInstructionHome}, so the engine is handed that one. The
+ * resolved path is passed rather than the raw value, so the engine and the doctor
+ * agree on `~` expansion too.
  *
  * Not a credential and never one: it cannot reintroduce anything the sanitizer
  * strips, and `extraEnv` still layers over it.
  */
 function engineOwnedEnv(env) {
     const out = {};
-    const home = (0, auth_core_1.readFirstPartyHarnessEnv)(env, 'home');
-    if (home.value && home.name !== auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.home) {
+    if ((0, auth_core_1.readFirstPartyHarnessEnv)(env, 'home').value) {
         out[auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.home] = engineInstructionHome(env);
     }
     return out;
@@ -615,7 +627,8 @@ async function execEngine(args, env = process.env, options = {}) {
     // Move an engine installed under an older binary name onto the canonical one,
     // BEFORE resolving. Idempotent, lossless, and it never throws: a move that
     // cannot be made leaves every file where it was, and `resolveEngine` still tries
-    // every spelling — so the worst case is today's path, never a missing engine.
+    // every artifact spelling — so the worst case is today's path, never a missing
+    // engine.
     // Here and not in `resolveEngine`, which the doctor also calls and which must
     // not move anything.
     (0, auth_core_1.migrateFirstPartyHarnessHome)({ env });

package/dist/lib/followups.d.ts

@@ -56,6 +56,8 @@ export interface FollowUpRow {
 export interface FollowUpCreateResponse {
     followup: FollowUpRow | null;
     reused?: boolean;
+    /** A reused reminder asked for at a different time moved to that time. */
+    rescheduled?: boolean;
     dropped?: false | 'budget';
     proposal?: boolean;
     budget?: Json;

package/dist/lib/harness-provider-input.d.ts

@@ -1,20 +1,25 @@
 /**
  * Harness-valued INPUT, normalised at the edge.
  *
- * The first-party harness has more than one accepted spelling while a rename is
- * in flight (`FIRST_PARTY_HARNESS.aliases`). Every flag, setting and filter that
- * takes a harness name must accept all of them — a script written against either
- * spelling keeps working — and must hand the rest of the CLI ONE value, so no
- * comparison downstream has to know there were two
- * (`docs/architecture/skrr-code-identifier-rename-2026-09-13.md` §2).
+ * INGRESS: every flag, setting and filter that takes a harness name accepts
+ * exactly the identity's ACCEPTED spellings (`firstPartyHarnessSpellings`) and
+ * hands the rest of the CLI ONE value, so no comparison downstream has to know
+ * whether there were several (`docs/architecture/skrr-code-identifier-rename-2026-09-13.md`
+ * §2). During a rename's alias window that is the canonical spelling plus
+ * `FIRST_PARTY_HARNESS.aliases`, so a script written against either keeps
+ * working; outside one it is the canonical spelling alone. A FORMER spelling is
+ * accepted on no input — it is passed through unchanged, so a flag offering only
+ * the accepted spellings rejects it — even though the CLI still recognises it on
+ * an engine binary already on disk (`first-party-harness.ts`).
  *
  * Two destinations, two spellings, and the difference is the point:
  *
  *   - to the SERVER (HTTP bodies, query params) and to the terminal: CANONICAL,
  *     which is what the platform stores and returns;
- *   - to the local DAEMON binary: the WIRE spelling, which every daemon version
- *     already installed on a user's machine understands. A daemon that predates
- *     the rename cannot be taught a new spelling by the CLI that talks to it.
+ *   - to the local DAEMON binary: the WIRE spelling (`wireProvider`). It sits on
+ *     the old spelling from a rename's flip until its wire phase, because a daemon
+ *     that predates the rename cannot be taught a new spelling by the CLI that
+ *     talks to it, and is canonical otherwise.
  *
  * Every other harness name passes through unchanged — this normalises one
  * harness's spellings, it is not a general lower-caser, and silently rewriting a
@@ -28,8 +33,9 @@ export declare function canonicalHarnessInputs(values: readonly string[]): strin
 export declare function daemonHarnessArgument(value: string): string;
 /**
  * The `options` list for an oclif flag that enumerates harness names: the given
- * names with every spelling of the first-party harness in place of its canonical
- * one, so oclif's own validation accepts an alias instead of rejecting it before
- * the command ever runs.
+ * names with every ACCEPTED spelling of the first-party harness in place of its
+ * canonical one, so oclif's own validation accepts an alias instead of rejecting
+ * it before the command ever runs — and rejects a former spelling, which no
+ * ingress accepts.
  */
 export declare function harnessFlagOptions(names: readonly string[]): string[];

package/dist/lib/harness-provider-input.js

@@ -2,20 +2,25 @@
 /**
  * Harness-valued INPUT, normalised at the edge.
  *
- * The first-party harness has more than one accepted spelling while a rename is
- * in flight (`FIRST_PARTY_HARNESS.aliases`). Every flag, setting and filter that
- * takes a harness name must accept all of them — a script written against either
- * spelling keeps working — and must hand the rest of the CLI ONE value, so no
- * comparison downstream has to know there were two
- * (`docs/architecture/skrr-code-identifier-rename-2026-09-13.md` §2).
+ * INGRESS: every flag, setting and filter that takes a harness name accepts
+ * exactly the identity's ACCEPTED spellings (`firstPartyHarnessSpellings`) and
+ * hands the rest of the CLI ONE value, so no comparison downstream has to know
+ * whether there were several (`docs/architecture/skrr-code-identifier-rename-2026-09-13.md`
+ * §2). During a rename's alias window that is the canonical spelling plus
+ * `FIRST_PARTY_HARNESS.aliases`, so a script written against either keeps
+ * working; outside one it is the canonical spelling alone. A FORMER spelling is
+ * accepted on no input — it is passed through unchanged, so a flag offering only
+ * the accepted spellings rejects it — even though the CLI still recognises it on
+ * an engine binary already on disk (`first-party-harness.ts`).
  *
  * Two destinations, two spellings, and the difference is the point:
  *
  *   - to the SERVER (HTTP bodies, query params) and to the terminal: CANONICAL,
  *     which is what the platform stores and returns;
- *   - to the local DAEMON binary: the WIRE spelling, which every daemon version
- *     already installed on a user's machine understands. A daemon that predates
- *     the rename cannot be taught a new spelling by the CLI that talks to it.
+ *   - to the local DAEMON binary: the WIRE spelling (`wireProvider`). It sits on
+ *     the old spelling from a rename's flip until its wire phase, because a daemon
+ *     that predates the rename cannot be taught a new spelling by the CLI that
+ *     talks to it, and is canonical otherwise.
  *
  * Every other harness name passes through unchanged — this normalises one
  * harness's spellings, it is not a general lower-caser, and silently rewriting a
@@ -48,9 +53,10 @@ function daemonHarnessArgument(value) {
 }
 /**
  * The `options` list for an oclif flag that enumerates harness names: the given
- * names with every spelling of the first-party harness in place of its canonical
- * one, so oclif's own validation accepts an alias instead of rejecting it before
- * the command ever runs.
+ * names with every ACCEPTED spelling of the first-party harness in place of its
+ * canonical one, so oclif's own validation accepts an alias instead of rejecting
+ * it before the command ever runs — and rejects a former spelling, which no
+ * ingress accepts.
  */
 function harnessFlagOptions(names) {
     return canonicalHarnessInputs(names).flatMap((name) => (0, auth_core_1.isFirstPartyHarnessProvider)(name) ? [...(0, auth_core_1.firstPartyHarnessSpellings)()] : [name]);

package/dist/lib/harness-tiers.d.ts

@@ -47,9 +47,10 @@ export declare const HARNESS_TIER_AUTHORITY = "daemon/src/harness-trust.ts";
 /**
  * The tier the shared table records for a harness, or `null` for an unknown name.
  *
- * Canonicalised first, so no spelling of the first-party harness can reach the
- * lookup as an unknown name — the shared table also carries every spelling, and
- * this keeps the answer right even for one written in a different case.
+ * Canonicalised first, so no accepted spelling of the first-party harness can reach
+ * the lookup as an unknown name — the shared table also carries every accepted
+ * spelling, and this keeps the answer right even for one written in a different
+ * case. A retired spelling is an unknown name here, as everywhere trust is decided.
  */
 export declare function mirroredTier(harness: string): HarnessTrustTier | null;
 export interface TierDescription {

package/dist/lib/harness-tiers.js

@@ -52,9 +52,10 @@ exports.HARNESS_TIER_AUTHORITY = 'daemon/src/harness-trust.ts';
 /**
  * The tier the shared table records for a harness, or `null` for an unknown name.
  *
- * Canonicalised first, so no spelling of the first-party harness can reach the
- * lookup as an unknown name — the shared table also carries every spelling, and
- * this keeps the answer right even for one written in a different case.
+ * Canonicalised first, so no accepted spelling of the first-party harness can reach
+ * the lookup as an unknown name — the shared table also carries every accepted
+ * spelling, and this keeps the answer right even for one written in a different
+ * case. A retired spelling is an unknown name here, as everywhere trust is decided.
  */
 function mirroredTier(harness) {
     const key = String((0, auth_core_1.canonicalHarnessProvider)(harness));

package/dist/lib/html-text.js

@@ -19,10 +19,35 @@ exports.htmlToDisplayText = htmlToDisplayText;
 function looksLikeHtml(value) {
     return /<\/?[a-z][^>]*>/i.test(value);
 }
+/** Pull one attribute out of a tag body — `src="…"`, `src='…'`, `src=…`. */
+function tagAttr(tag, name) {
+    const m = new RegExp(`${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(tag);
+    return m ? (m[1] ?? m[2] ?? m[3] ?? '') : '';
+}
 function htmlToDisplayText(value) {
     if (!looksLikeHtml(value))
         return value;
     return (value
+        // A <video> is the same kind of meaning as an <img>, and the tag strip
+        // would erase it the same way, leaving a terminal reader no sign the
+        // description holds a recording at all. Markdown has no video syntax, so
+        // it becomes a labelled link to the stable reference. The element's
+        // children — `<source>` and fallback text — go with it; a `<source>` src
+        // is used when the element itself carries none (OSK-10129).
+        .replace(/<video\b([^>]*)>([\s\S]*?)<\/video\s*>|<video\b([^>]*)\/?>/gi, (_m, open, inner, bare) => {
+        const tag = String(open ?? bare ?? '');
+        const src = tagAttr(tag, 'src') || tagAttr(/<source\b[^>]*>/i.exec(inner ?? '')?.[0] ?? '', 'src');
+        const title = tagAttr(tag, 'title');
+        return src ? `[video: ${title || 'recording'}](${src})\n` : '';
+    })
+        // An <img> carries meaning — the asset reference or URL — that the
+        // generic tag strip below would erase entirely. Keep it as a markdown
+        // image so `task-asset:<id>` refs stay legible in a terminal (OSK-9856).
+        .replace(/<img\b[^>]*>/gi, (tag) => {
+        const src = tagAttr(tag, 'src');
+        const alt = tagAttr(tag, 'alt');
+        return src ? `![${alt || 'image'}](${src})` : '';
+    })
         .replace(/<br\s*\/?>/gi, '\n')
         .replace(/<\/(p|div|li|h[1-6])>/gi, '\n')
         .replace(/<li[^>]*>/gi, '  - ')

package/dist/lib/local-skills.d.ts

@@ -112,3 +112,30 @@ export declare const SKILL_CONVENTION_DISCOVERY_SINCE = "0.8.44";
  * add an explanation, and claiming an unknown daemon is old would be a guess.
  */
 export declare function daemonPredates(version: string | null | undefined, floor: string): boolean;
+/**
+ * The table, summary and exit decision for `skills import-as-actions`.
+ *
+ * A skill that imported without its action because the library was full used to
+ * show only `limit_reached`, an empty detail, "0 skill(s) failed" and exit 0, so
+ * a script or agent concluded every action it asked for was added (OSK-10185).
+ * `already_exists` stays a success: the action the caller wanted is there.
+ */
+export declare function summarizeSkillActionImport(result: {
+    targetAgentId: string;
+    actionsCreated: number;
+    results: Array<{
+        name: string;
+        status: string;
+        error?: string;
+        actionCreated?: boolean;
+        actionSkippedReason?: string;
+        actionError?: string;
+    }>;
+    actionsError?: {
+        message: string;
+    } | null;
+}): {
+    rows: Array<Record<string, string>>;
+    summary: string;
+    failed: boolean;
+};

package/dist/lib/local-skills.js

@@ -10,6 +10,7 @@ exports.looksLikeSkillPath = looksLikeSkillPath;
 exports.findLocalSkillsNamed = findLocalSkillsNamed;
 exports.describeStoreSkillMiss = describeStoreSkillMiss;
 exports.daemonPredates = daemonPredates;
+exports.summarizeSkillActionImport = summarizeSkillActionImport;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const instruction_input_1 = require("./instruction-input");
 /**
@@ -211,3 +212,40 @@ function daemonPredates(version, floor) {
     }
     return false;
 }
+/** Why a skill imported but got no action, in words a person or an agent can act on. */
+const ACTION_SKIP_DETAIL = {
+    limit_reached: "this agent's action library is full; delete an action, then run the import again to add it",
+    already_exists: 'an action for this skill is already offered at this scope',
+};
+/**
+ * The table, summary and exit decision for `skills import-as-actions`.
+ *
+ * A skill that imported without its action because the library was full used to
+ * show only `limit_reached`, an empty detail, "0 skill(s) failed" and exit 0, so
+ * a script or agent concluded every action it asked for was added (OSK-10185).
+ * `already_exists` stays a success: the action the caller wanted is there.
+ */
+function summarizeSkillActionImport(result) {
+    const failed = result.results.filter((r) => r.status === 'failed');
+    const overCap = result.results.filter((r) => r.status !== 'failed' && r.actionSkippedReason === 'limit_reached');
+    const rows = result.results.map((r) => ({
+        skill: r.name,
+        import: r.status,
+        action: r.actionCreated
+            ? 'created'
+            : (r.actionSkippedReason ?? r.actionError ?? (r.status === 'failed' ? '-' : 'not added')),
+        detail: r.error ??
+            r.actionError ??
+            (r.actionSkippedReason ? (ACTION_SKIP_DETAIL[r.actionSkippedReason] ?? '') : ''),
+    }));
+    const summary = `${result.actionsCreated} action(s) created on ${result.targetAgentId}; ` +
+        `${failed.length} skill(s) failed` +
+        (overCap.length > 0
+            ? `; ${overCap.length} skill(s) imported without an action because the action library is full.`
+            : '.');
+    return {
+        rows,
+        summary,
+        failed: failed.length > 0 || overCap.length > 0 || Boolean(result.actionsError),
+    };
+}

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

@@ -7,7 +7,7 @@
  * is no `task-read` and adding one to make the table tidy would name a resource
  * after an access mode.
  */
-export type SessionTaskOperation = 'completion' | 'move' | 'comment' | 'event' | 'update' | 'result' | 'resume' | 'resumeRead' | 'deliverable' | 'review' | 'assessment' | 'read';
+export type SessionTaskOperation = 'completion' | 'move' | 'comment' | 'event' | 'update' | 'result' | 'resume' | 'resumeRead' | 'deliverable' | 'review' | 'assessment' | 'attachment' | 'attachmentIntent' | 'attachmentComplete' | 'read';
 /** Path suffix per operation. Exported for the parity test, not for callers. */
 export declare const SESSION_TASK_PATH_SUFFIX: Record<SessionTaskOperation, string>;
 /**

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

@@ -47,6 +47,9 @@ exports.SESSION_TASK_PATH_SUFFIX = {
     deliverable: 'task-deliverables',
     review: 'task-review',
     assessment: 'task-expectation-assessment',
+    attachment: 'task-attachments',
+    attachmentIntent: 'task-attachments/intent',
+    attachmentComplete: 'task-attachments/complete',
     read: 'task',
 };
 /**

package/dist/lib/task-asset-upload.d.ts

@@ -0,0 +1,84 @@
+export type TaskAssetRole = 'input' | 'evidence' | 'deliverable';
+export interface UploadedTaskAsset {
+    id: string;
+    /**
+     * sha256 (hex) of the bytes the server STORED, as the server recorded them.
+     * Absent when the server did not report one — never back-filled from the
+     * local file, which is a different version for any canonicalized image.
+     */
+    digest?: string;
+    filename: string;
+    mimeType: string;
+    /** True when the server returned an existing row for the same sha256. */
+    deduplicated: boolean;
+}
+/** The citation an Update or Result appends to `evidenceRefs`. */
+export interface TaskAssetEvidenceRef {
+    kind: 'task_attachment';
+    id: string;
+    /** `sha256:<hex>` of the stored bytes; omitted when the server named none. */
+    digest?: string;
+}
+/**
+ * Read the Task an upload targets, through the same credential the upload
+ * will use. In a session the task comes from the claim, so the read is the
+ * bound task and `taskId` is only reconciled against it — a scoped credential
+ * refuses to act on any other task before a byte leaves the machine.
+ */
+export declare function readTaskForUpload(taskId: string): Promise<Record<string, unknown>>;
+/**
+ * Upload `filePath` as a Task asset. In a session the task comes from the
+ * claim — `taskId` is only reconciled against the binding, never sent.
+ * Throws a plain Error; callers decide how to surface it.
+ */
+export declare function uploadTaskAssetFile(opts: {
+    taskId: string;
+    filePath: string;
+    role?: TaskAssetRole;
+}): Promise<UploadedTaskAsset>;
+/**
+ * Upload every `--attach` file and return the reference objects an Update or
+ * Result appends to `evidenceRefs`. Serial: half a dozen files is the
+ * realistic case and parallel uploads would race the session rate limiter.
+ */
+export declare function attachTaskAssetFiles(opts: {
+    taskId: string;
+    files: string[];
+    role: TaskAssetRole;
+}): Promise<TaskAssetEvidenceRef[]>;
+/**
+ * The markdown image a comment body carries for an asset. The alt text is the
+ * filename, so its brackets are escaped: `shot [final].png` would otherwise
+ * close the alt early and break the reference.
+ */
+export declare function taskAssetMarkdownRef(asset: {
+    id: string;
+    filename: string;
+}): string;
+/** sha256 of a file, read as a stream: a 250MB recording never sits in memory. */
+export declare function sha256OfFile(filePath: string): Promise<string>;
+/**
+ * POST the file to the presigned URL as multipart/form-data, streamed from
+ * disk.
+ *
+ * Built by hand rather than with `FormData` + `fetch` for two reasons, both
+ * about large files. `FormData` needs a `Blob`, which here means the whole
+ * file in memory — the double buffering this replaced read up to 250MB and
+ * then copied it again. And storage refuses a POST without a Content-Length
+ * (it does not take chunked uploads), which a streamed `fetch` body cannot
+ * promise; the exact length is known here, because every part except the file
+ * is a small in-memory string and the file's size came from `stat`.
+ *
+ * `file` goes LAST — S3 presigned POST evaluates fields in order and ignores
+ * anything after it. The fields carry `x-amz-checksum-sha256`, so storage
+ * itself rejects bytes that do not match the digest the intent declared,
+ * including a file that changed between hashing and upload.
+ */
+export declare function postFileToStorage(p: {
+    uploadUrl: string;
+    uploadFields: Record<string, string>;
+    filePath: string;
+    size: number;
+    filename: string;
+    mimeType: string;
+}): Promise<void>;