runline 0.21.0 → 0.23.0

package/dist/plugins/_shared/shiftUpload.js

@@ -0,0 +1,118 @@
+import { openAsBlob } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { extname } from "node:path";
+/**
+ * The Shift cloud signed-grant upload arc, shared by every plugin that
+ * moves local file bytes into the cloud (shiftTranscription assets,
+ * shiftObjects objects): stat + size-gate the file, create the server
+ * record with { contentType, sizeBytes }, PUT the bytes to the grant
+ * URL with the grant's headers, then POST /complete. The subtle parts
+ * live here once: the openAsBlob streaming fallback, grant-header
+ * merging, and the size ceilings.
+ *
+ * shiftOcr deliberately does not use this arc — it inlines small files
+ * as base64 data URLs instead of uploading through a grant.
+ */
+/** Mirrors the public service contracts' 5 GiB upload ceiling. */
+export const SIGNED_UPLOAD_MAX_BYTES = 5 * 1024 * 1024 * 1024;
+/**
+ * Runtimes without fs.openAsBlob fall back to buffering; refuse to
+ * buffer files that would strain the host process.
+ */
+const MAX_BUFFERED_BYTES = 512 * 1024 * 1024;
+/** Audio and video formats the transcription service accepts. */
+export const AUDIO_VIDEO_MEDIA_TYPES = {
+    aac: "audio/aac",
+    flac: "audio/flac",
+    m4a: "audio/m4a",
+    mov: "video/quicktime",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    mpeg: "video/mpeg",
+    mpg: "video/mpeg",
+    oga: "audio/ogg",
+    ogg: "audio/ogg",
+    opus: "audio/ogg",
+    wav: "audio/wav",
+    wave: "audio/wav",
+    webm: "video/webm",
+};
+/** Common document, image, and media formats for durable objects. */
+export const GENERAL_MEDIA_TYPES = {
+    csv: "text/csv",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    gif: "image/gif",
+    html: "text/html",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    json: "application/json",
+    md: "text/markdown",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    pdf: "application/pdf",
+    png: "image/png",
+    txt: "text/plain",
+    wav: "audio/wav",
+    webp: "image/webp",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    zip: "application/zip",
+};
+/** Extension-based media type lookup; undefined when unknown. */
+export function mediaTypeFromPath(path, types) {
+    return types[extname(path).slice(1).toLowerCase()];
+}
+/** Like {@link mediaTypeFromPath}, but unknown extensions are an error. */
+export function requireMediaType(path, types) {
+    const mediaType = mediaTypeFromPath(path, types);
+    if (!mediaType) {
+        throw new Error(`Unsupported media extension for ${path}. Supported: ${Object.keys(types).join(", ")}`);
+    }
+    return mediaType;
+}
+/**
+ * Gate a local file before any network call: it must exist, be a real
+ * file, be non-empty, and fit the service ceiling. Returns its size.
+ * The label keeps each plugin's established error vocabulary
+ * ("File is empty" vs "Media file is empty").
+ */
+export async function statUploadFile(path, maxBytes, label = "File") {
+    const file = await stat(path);
+    if (!file.isFile())
+        throw new Error(`${path} is not a file`);
+    if (file.size === 0)
+        throw new Error(`${label} is empty`);
+    if (file.size > maxBytes) {
+        throw new Error(`${label} is larger than the ${maxBytes}-byte service limit`);
+    }
+    return file.size;
+}
+async function fileBody(path, sizeBytes) {
+    try {
+        return await openAsBlob(path);
+    }
+    catch {
+        if (sizeBytes > MAX_BUFFERED_BYTES) {
+            throw new Error("This runtime cannot stream uploads and the file is too large to buffer.");
+        }
+        return await readFile(path);
+    }
+}
+/**
+ * PUT a local file's bytes to a signed grant. Grant headers win;
+ * content-type is filled in only when the grant leaves it unset.
+ */
+export async function putThroughGrant(grant, path, contentType, sizeBytes, label = "Upload") {
+    const headers = new Headers(grant.headers);
+    if (!headers.has("content-type")) {
+        headers.set("content-type", contentType);
+    }
+    const response = await fetch(grant.url, {
+        method: grant.method,
+        headers,
+        body: await fileBody(path, sizeBytes),
+    });
+    if (!response.ok) {
+        throw new Error(`${label} failed: HTTP ${response.status}`);
+    }
+}

package/dist/plugins/shiftAtlas/src/graph.js

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { ATLAS_BASE, cursorSchema, enumSchema, GRAPH_ACTOR_KIND, GRAPH_ASSIGNMENT_ROLE, GRAPH_BINDING_EXECUTOR, GRAPH_BINDING_STATUS, GRAPH_CHANGE_ENTITY_TYPE, GRAPH_EVIDENCE_KIND, GRAPH_JOURNEY_STATUS, GRAPH_RELATION_KIND, GRAPH_TASK_MODE, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, } from "./shared.js";
+import { ATLAS_BASE, cursorSchema, enumSchema, GRAPH_ACTOR_KIND, GRAPH_ASSIGNMENT_ROLE, GRAPH_BINDING_EXECUTOR, GRAPH_BINDING_STATUS, GRAPH_CHANGE_ENTITY_TYPE, GRAPH_EVIDENCE_KIND, GRAPH_JOURNEY_STATUS, GRAPH_RELATION_KIND, GRAPH_TASK_MODE, idSchema, listParams, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, withQuery, } from "./shared.js";
 /**
  * The operational graph behind the Atlas view: a business spec of how
  * a company operates, in its own language. Four fixed levels — line →
@@ -121,12 +121,7 @@ export function registerGraphActions(rl) {
             limit: t.Optional(t.Integer({ minimum: 1, maximum: 200 })),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const params = new URLSearchParams();
-            for (const [key, value] of Object.entries(input)) {
-                if (value !== undefined)
-                    params.set(key, String(value));
-            }
-            return request(ctx, `${ATLAS_BASE}/changes?${params}`);
+            return request(ctx, withQuery(`${ATLAS_BASE}/changes`, listParams(input)));
         },
     });
     /* -------------------------------------------------------------- */

package/dist/plugins/shiftAtlas/src/shared.js

@@ -1,4 +1,4 @@
-export { cursorSchema, enumSchema, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, } from "../../_shared/shiftCloud.js";
+export { cursorSchema, enumSchema, idSchema, listParams, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, withQuery, } from "../../_shared/shiftCloud.js";
 /** Base path of the operational graph service in the Shift cloud API. */
 export const ATLAS_BASE = "/v1/services/operational-graph";
 export const GRAPH_ACTOR_KIND = ["agent", "human_role"];

package/dist/plugins/shiftObjects/src/index.js

@@ -0,0 +1,20 @@
+import * as t from "typebox";
+import { registerObjectActions } from "./objects.js";
+/**
+ * Shift Objects — the organization's durable object bucket in the
+ * Shift cloud: upload binary files through signed grants, mint
+ * download grants, and record append-only provenance links. The API
+ * key is the tenant authority; the cloud derives the organization from
+ * it (SHFT-852), so no org ID is sent.
+ */
+export default function shiftObjects(rl) {
+    rl.setName("shiftObjects");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            description: "Shift Labs API key",
+            env: "SHIFT_LABS_API_KEY",
+        }),
+    }));
+    registerObjectActions(rl);
+}

package/dist/plugins/{shiftLabs → shiftObjects}/src/objects.js

@@ -1,8 +1,8 @@
-import { openAsBlob } from "node:fs";
-import { readFile, stat, writeFile } from "node:fs/promises";
-import { basename, extname } from "node:path";
+import { writeFile } from "node:fs/promises";
+import { basename } from "node:path";
 import * as t from "typebox";
-import { enumSchema, pathSegment, request } from "./shared.js";
+import { enumSchema, listParams, pathSegment, request, withQuery, } from "../../_shared/shiftCloud.js";
+import { GENERAL_MEDIA_TYPES, mediaTypeFromPath, putThroughGrant, SIGNED_UPLOAD_MAX_BYTES, statUploadFile, } from "../../_shared/shiftUpload.js";
 const OBJECTS_BASE = "/v1/services/objects";
 export const OBJECT_STATUS = ["pending_upload", "ready", "archived"];
 export const OBJECT_LINK_TARGET = [
@@ -11,49 +11,8 @@ export const OBJECT_LINK_TARGET = [
     "eval_case",
     "db_record",
 ];
-/** Mirrors the public service contract's 5 GiB object ceiling. */
-const MAX_OBJECT_BYTES = 5 * 1024 * 1024 * 1024;
 const STRICT_OBJECT = { additionalProperties: false };
 const Id = t.String({ minLength: 1, pattern: "\\S" });
-const MEDIA_TYPES = {
-    csv: "text/csv",
-    doc: "application/msword",
-    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    gif: "image/gif",
-    html: "text/html",
-    jpeg: "image/jpeg",
-    jpg: "image/jpeg",
-    json: "application/json",
-    md: "text/markdown",
-    mp3: "audio/mpeg",
-    mp4: "video/mp4",
-    pdf: "application/pdf",
-    png: "image/png",
-    txt: "text/plain",
-    wav: "audio/wav",
-    webp: "image/webp",
-    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    zip: "application/zip",
-};
-function mediaTypeFor(path, override) {
-    if (override)
-        return override;
-    return (MEDIA_TYPES[extname(path).slice(1).toLowerCase()] ??
-        "application/octet-stream");
-}
-async function fileBody(path, sizeBytes) {
-    try {
-        return await openAsBlob(path);
-    }
-    catch {
-        // Runtimes without fs.openAsBlob fall back to buffering; refuse to
-        // buffer files that would strain the host process.
-        if (sizeBytes > 512 * 1024 * 1024) {
-            throw new Error("This runtime cannot stream uploads and the file is too large to buffer.");
-        }
-        return await readFile(path);
-    }
-}
 function linkSchema() {
     return t.Object({
         targetType: enumSchema("Link target type", OBJECT_LINK_TARGET),
@@ -108,21 +67,16 @@ export function registerObjectActions(rl) {
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
-            const contentType = mediaTypeFor(fields.path, fields.contentType);
-            const file = await stat(fields.path);
-            if (!file.isFile())
-                throw new Error(`${fields.path} is not a file`);
-            if (file.size === 0)
-                throw new Error("File is empty");
-            if (file.size > MAX_OBJECT_BYTES) {
-                throw new Error(`File is larger than the ${MAX_OBJECT_BYTES}-byte service limit`);
-            }
+            const contentType = fields.contentType ??
+                mediaTypeFromPath(fields.path, GENERAL_MEDIA_TYPES) ??
+                "application/octet-stream";
+            const sizeBytes = await statUploadFile(fields.path, SIGNED_UPLOAD_MAX_BYTES);
             const created = await request(ctx, `${OBJECTS_BASE}/objects`, {
                 method: "POST",
                 // The API key is the tenant authority; no organizationId is sent.
                 body: JSON.stringify({
                     contentType,
-                    sizeBytes: file.size,
+                    sizeBytes,
                     filename: fields.filename ?? basename(fields.path),
                     workspaceId: fields.workspaceId,
                     sessionId: fields.sessionId,
@@ -130,18 +84,7 @@ export function registerObjectActions(rl) {
                     metadata: fields.metadata,
                 }),
             });
-            const uploadHeaders = new Headers(created.upload.headers);
-            if (!uploadHeaders.has("content-type")) {
-                uploadHeaders.set("content-type", contentType);
-            }
-            const upload = await fetch(created.upload.url, {
-                method: created.upload.method,
-                headers: uploadHeaders,
-                body: await fileBody(fields.path, file.size),
-            });
-            if (!upload.ok) {
-                throw new Error(`Object upload failed: HTTP ${upload.status}`);
-            }
+            await putThroughGrant(created.upload, fields.path, contentType, sizeBytes, "Object upload");
             return request(ctx, `${OBJECTS_BASE}/objects/${pathSegment(created.object.id)}/complete`, { method: "POST" });
         },
     });
@@ -155,13 +98,7 @@ export function registerObjectActions(rl) {
             ...provenanceFields,
         }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const params = new URLSearchParams();
-            for (const [key, value] of Object.entries(input)) {
-                if (value !== undefined)
-                    params.set(key, String(value));
-            }
-            const query = params.toString();
-            const body = await request(ctx, `${OBJECTS_BASE}/objects${query ? `?${query}` : ""}`);
+            const body = await request(ctx, withQuery(`${OBJECTS_BASE}/objects`, listParams(input)));
             return body.objects;
         },
     });

package/dist/plugins/shiftOcr/src/index.js

@@ -1,11 +1,17 @@
-import { readFile, stat } from "node:fs/promises";
-import { extname } from "node:path";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
 import * as t from "typebox";
 import { request, STRICT_OBJECT } from "../../_shared/shiftCloud.js";
+import { putThroughGrant, SIGNED_UPLOAD_MAX_BYTES, statUploadFile, } from "../../_shared/shiftUpload.js";
 /**
  * Shift OCR — text and structured-field extraction from images and
  * PDFs through the Shift cloud OCR service. The API key is the tenant
  * authority; no organization ID is ever sent (SHFT-852).
+ *
+ * Local files route by size: small ones inline as base64 data URLs
+ * (one round-trip); larger ones ride the signed-grant arc into the
+ * organization's durable object bucket and extract by objectId
+ * (SHFT-924), so bytes go to S3, never through the API.
  */
 const IMAGE_TYPES = {
     avif: "image/avif",
@@ -20,10 +26,11 @@ const DOCUMENT_TYPES = {
 };
 /**
  * Raw-file ceiling for inlining as a base64 data URL. Base64 inflates
- * by 4/3, so 20 MiB raw stays well inside provider request limits.
+ * by 4/3, so 20 MiB raw stays well inside provider request limits;
+ * anything larger uploads to the object bucket instead.
  */
-const MAX_FILE_BYTES = 20 * 1024 * 1024;
-async function documentFromPath(path) {
+const MAX_INLINE_BYTES = 20 * 1024 * 1024;
+async function documentFromPath(ctx, path) {
     const extension = extname(path).slice(1).toLowerCase();
     const imageType = IMAGE_TYPES[extension];
     const documentType = DOCUMENT_TYPES[extension];
@@ -33,19 +40,27 @@ async function documentFromPath(path) {
             ...Object.keys(DOCUMENT_TYPES),
         ].join(", ")}`);
     }
-    const file = await stat(path);
-    if (!file.isFile())
-        throw new Error(`${path} is not a file`);
-    if (file.size === 0)
-        throw new Error("File is empty");
-    if (file.size > MAX_FILE_BYTES) {
-        throw new Error(`File is ${file.size} bytes; inline OCR uploads are capped at ${MAX_FILE_BYTES} bytes. Host the file and pass url instead.`);
+    const mediaType = (imageType ?? documentType);
+    const sizeBytes = await statUploadFile(path, SIGNED_UPLOAD_MAX_BYTES);
+    if (sizeBytes <= MAX_INLINE_BYTES) {
+        const url = `data:${mediaType};base64,${(await readFile(path)).toString("base64")}`;
+        return imageType
+            ? { type: "image", url }
+            : { type: "document", url, name: basename(path) };
     }
-    const mediaType = imageType ?? documentType;
-    const url = `data:${mediaType};base64,${(await readFile(path)).toString("base64")}`;
-    return imageType
-        ? { type: "image", url }
-        : { type: "document", url, name: path.replace(/.*\//, "") };
+    // Large file: into the durable bucket through a signed grant, then
+    // extract by reference — the object persists as provenance.
+    const created = await request(ctx, "/v1/services/objects/objects", {
+        method: "POST",
+        body: JSON.stringify({
+            contentType: mediaType,
+            sizeBytes,
+            filename: basename(path),
+        }),
+    });
+    await putThroughGrant(created.upload, path, mediaType, sizeBytes);
+    await request(ctx, `/v1/services/objects/objects/${created.object.id}/complete`, { method: "POST" });
+    return { type: "object", objectId: created.object.id };
 }
 function documentFromUrl(url, kind) {
     if (kind)
@@ -75,9 +90,10 @@ export default function shiftOcr(rl) {
     rl.registerAction("ocr.extract", {
         access: "write",
         description: "Extract markdown text — and optionally schema-constrained JSON — " +
-            "from an image or PDF. Pass a local file path (inlined as a data " +
-            "URL) or an https URL. Provide schema to get structured fields " +
-            "back instead of parsing the text yourself.",
+            "from an image or PDF. Pass a local file path (small files inline; " +
+            "large ones upload to the org's object bucket automatically), an " +
+            "https URL, or the objectId of a stored object. Provide schema to " +
+            "get structured fields back instead of parsing the text yourself.",
         inputSchema: t.Object({
             path: t.Optional(t.String({
                 minLength: 1,
@@ -89,10 +105,26 @@ export default function shiftOcr(rl) {
                 pattern: "\\S",
                 description: "https or data URL of the image or PDF",
             })),
+            objectId: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "ID of a ready object in the organization's durable bucket",
+            })),
             kind: t.Optional(t.Union([t.Literal("image"), t.Literal("document")], {
                 description: "Override for URLs whose extension does not reveal the type. " +
                     "Inferred from the extension otherwise.",
             })),
+            provider: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "Provider ID from ocr.providers. Defaults to the first " +
+                    "catalog provider.",
+            })),
+            model: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "Model override. Defaults to the provider's defaultModel.",
+            })),
             pages: t.Optional(t.String({
                 minLength: 1,
                 pattern: "^\\d+(-\\d+)?(,\\d+(-\\d+)?)*$",
@@ -114,19 +146,24 @@ export default function shiftOcr(rl) {
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
-            if (!fields.path === !fields.url) {
-                throw new Error("Provide exactly one of path or url");
+            const sources = [fields.path, fields.url, fields.objectId].filter((value) => value !== undefined);
+            if (sources.length !== 1) {
+                throw new Error("Provide exactly one of path, url, or objectId");
             }
             if (fields.prompt && !fields.schema) {
                 throw new Error("prompt requires schema");
             }
-            const document = fields.path
-                ? await documentFromPath(fields.path)
-                : documentFromUrl(fields.url, fields.kind);
+            const document = fields.objectId
+                ? { type: "object", objectId: fields.objectId }
+                : fields.path
+                    ? await documentFromPath(ctx, fields.path)
+                    : documentFromUrl(fields.url, fields.kind);
             return await request(ctx, "/v1/services/ocr/extract", {
                 method: "POST",
                 body: JSON.stringify({
                     document,
+                    ...(fields.provider ? { provider: fields.provider } : {}),
+                    ...(fields.model ? { model: fields.model } : {}),
                     ...(fields.pages ? { pages: fields.pages } : {}),
                     ...(fields.schema
                         ? {

package/dist/plugins/shiftPages/src/index.js

@@ -0,0 +1,19 @@
+import * as t from "typebox";
+import { registerPageActions } from "./pages.js";
+/**
+ * Shift Pages — hosted HTML pages in the Shift cloud: draft, publish,
+ * archive, share with invited viewers, and resolve authenticated
+ * render URLs. The API key is the tenant authority; the cloud derives
+ * the organization from it (SHFT-852), so no org ID is sent.
+ */
+export default function shiftPages(rl) {
+    rl.setName("shiftPages");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            description: "Shift Labs API key",
+            env: "SHIFT_LABS_API_KEY",
+        }),
+    }));
+    registerPageActions(rl);
+}

package/dist/plugins/{shiftLabs → shiftPages}/src/pages.js

@@ -1,11 +1,18 @@
 import * as t from "typebox";
-import { enumSchema, idSchema, PAGE_STATUS, PAGE_VISIBILITY, pageRenderUrl, pathSegment, request, STRICT_OBJECT, timestampSchema, } from "./shared.js";
+import { enumSchema, idSchema, listParams, PAGE_STATUS, PAGE_TYPE, PAGE_VISIBILITY, pageRenderUrl, pathSegment, request, STRICT_OBJECT, timestampSchema, withQuery, } from "./shared.js";
 const PageSlug = t.String({
     minLength: 1,
     maxLength: 120,
     pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$",
     description: "Lowercase kebab-case page slug",
 });
+const OriginUrl = t.String({
+    minLength: 1,
+    format: "uri",
+    pattern: "^https://",
+    description: "HTTPS origin to proxy behind SSO (protected_origin pages only). " +
+        "Localhost and private IP hosts are rejected.",
+});
 export function registerPageActions(rl) {
     rl.registerAction("page.list", {
         access: "read",
@@ -19,13 +26,7 @@ export function registerPageActions(rl) {
             })),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const fields = (input ?? {});
-            const params = new URLSearchParams();
-            if (fields.status)
-                params.set("status", String(fields.status));
-            if (fields.limit)
-                params.set("limit", String(fields.limit));
-            const body = await request(ctx, `/v1/pages?${params}`);
+            const body = await request(ctx, withQuery("/v1/pages", listParams(input)));
             return body.pages;
         },
     });
@@ -39,9 +40,23 @@ export function registerPageActions(rl) {
             return body.page;
         },
     });
+    rl.registerAction("page.vexArtifacts", {
+        access: "read",
+        description: "List the shareable Vex artifacts on a managed deployment, sorted by " +
+            "title, each carrying the workspace it belongs to. Pass an artifact's " +
+            "ID to page.create with type vex_artifact to publish it. The " +
+            "deployment must belong to the API key's organization.",
+        inputSchema: t.Object({ deploymentId: idSchema("Managed Vex deployment ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const body = await request(ctx, withQuery("/v1/pages/vex-artifacts", listParams(input)));
+            return body.artifacts;
+        },
+    });
     rl.registerAction("page.create", {
         access: "write",
-        description: "Create a draft hosted HTML page. Agents can publish it with page.publish.",
+        description: "Create a draft page and publish it with page.publish. hosted_html " +
+            "pages carry their own HTML; vex_artifact pages render a live Vex " +
+            "artifact (pass deploymentId and artifactId from page.vexArtifacts).",
         inputSchema: t.Object({
             slug: PageSlug,
             title: t.String({
@@ -50,14 +65,19 @@ export function registerPageActions(rl) {
                 pattern: "\\S",
                 description: "Page title",
             }),
+            type: t.Optional(enumSchema("Page type", PAGE_TYPE)),
             html: t.Optional(t.String({
                 maxLength: 1_000_000,
-                description: "Hosted HTML content",
+                description: "Hosted HTML content (hosted_html pages only)",
             })),
+            originUrl: t.Optional(OriginUrl),
+            deploymentId: t.Optional(idSchema("Managed Vex deployment ID (vex_artifact pages only)")),
+            artifactId: t.Optional(idSchema("Vex artifact ID (vex_artifact pages only)")),
             visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
+            assertPageContent(fields);
             const body = await request(ctx, "/v1/pages", {
                 method: "POST",
                 body: JSON.stringify({
@@ -71,7 +91,9 @@ export function registerPageActions(rl) {
     });
     rl.registerAction("page.update", {
         access: "write",
-        description: "Update a hosted HTML page's slug, title, visibility, or HTML.",
+        description: "Update a page's slug, title, visibility, HTML, or — for vex_artifact " +
+            "pages — which deployment and artifact it renders. A page's type is " +
+            "fixed at creation.",
         inputSchema: t.Object({
             id: idSchema("Page ID"),
             slug: t.Optional(PageSlug),
@@ -84,8 +106,11 @@ export function registerPageActions(rl) {
             visibility: t.Optional(enumSchema("Page visibility", PAGE_VISIBILITY)),
             html: t.Optional(t.String({
                 maxLength: 1_000_000,
-                description: "Hosted HTML content",
+                description: "Hosted HTML content (hosted_html pages only)",
             })),
+            originUrl: t.Optional(OriginUrl),
+            deploymentId: t.Optional(idSchema("Managed Vex deployment ID (vex_artifact pages only)")),
+            artifactId: t.Optional(idSchema("Vex artifact ID (vex_artifact pages only)")),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, ...fields } = input;
@@ -98,7 +123,8 @@ export function registerPageActions(rl) {
     });
     rl.registerAction("page.publish", {
         access: "write",
-        description: "Publish a Shift Labs hosted HTML page.",
+        description: "Publish a draft page, making it reachable at its render URL by the " +
+            "organization (or by invited viewers when visibility is invited).",
         inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id } = input;
@@ -119,10 +145,10 @@ export function registerPageActions(rl) {
     rl.registerAction("page.shares", {
         access: "read",
         description: "List shares for a Shift Labs page.",
-        inputSchema: t.Object({ pageId: idSchema("Page ID") }, STRICT_OBJECT),
+        inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { pageId } = input;
-            const body = await request(ctx, `/v1/pages/${pathSegment(pageId)}/shares`);
+            const { id } = input;
+            const body = await request(ctx, `/v1/pages/${pathSegment(id)}/shares`);
             return body.shares;
         },
     });
@@ -130,7 +156,7 @@ export function registerPageActions(rl) {
         access: "write",
         description: "Create a viewer share for a Shift Labs page.",
         inputSchema: t.Object({
-            pageId: idSchema("Page ID"),
+            id: idSchema("Page ID"),
             email: t.String({
                 minLength: 1,
                 format: "email",
@@ -139,8 +165,8 @@ export function registerPageActions(rl) {
             expiresAt: t.Optional(timestampSchema("Optional ISO-8601 expiration")),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { pageId, ...fields } = input;
-            const body = await request(ctx, `/v1/pages/${pathSegment(String(pageId))}/shares`, {
+            const { id, ...fields } = input;
+            const body = await request(ctx, `/v1/pages/${pathSegment(String(id))}/shares`, {
                 method: "POST",
                 body: JSON.stringify(fields),
             });
@@ -162,13 +188,38 @@ export function registerPageActions(rl) {
     rl.registerAction("page.renderUrl", {
         access: "read",
         description: "Return the authenticated render URL for a page.",
-        inputSchema: t.Object({ pageId: idSchema("Page ID") }, STRICT_OBJECT),
+        inputSchema: t.Object({ id: idSchema("Page ID") }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { pageId } = input;
-            const body = await request(ctx, `/v1/pages/${pathSegment(pageId)}`);
+            const { id } = input;
+            const body = await request(ctx, `/v1/pages/${pathSegment(id)}`);
             return {
                 url: pageRenderUrl(body.page.organizationId, body.page.slug),
             };
         },
     });
 }
+/**
+ * The content rules the API enforces per page type, checked before the
+ * round-trip so a caller gets the reason rather than a bare 400. Each
+ * type owns exactly one content field.
+ */
+function assertPageContent(fields) {
+    const type = fields.type ?? "hosted_html";
+    const referencesArtifact = fields.deploymentId !== undefined || fields.artifactId !== undefined;
+    if (type !== "vex_artifact" && referencesArtifact) {
+        throw new Error("Only vex_artifact pages may reference a deployment or artifact");
+    }
+    if (type !== "protected_origin" && fields.originUrl !== undefined) {
+        throw new Error("Only protected_origin pages may set an originUrl");
+    }
+    if (type !== "hosted_html" && fields.html !== undefined) {
+        throw new Error("Only hosted_html pages may carry html");
+    }
+    if (type === "vex_artifact" &&
+        (fields.deploymentId === undefined || fields.artifactId === undefined)) {
+        throw new Error("vex_artifact pages require both deploymentId and artifactId");
+    }
+    if (type === "protected_origin" && fields.originUrl === undefined) {
+        throw new Error("protected_origin pages require an originUrl");
+    }
+}

package/dist/plugins/shiftPages/src/shared.js

@@ -0,0 +1,12 @@
+import { baseUrl, pathSegment } from "../../_shared/shiftCloud.js";
+export { enumSchema, idSchema, listParams, pathSegment, request, STRICT_OBJECT, timestampSchema, withQuery, } from "../../_shared/shiftCloud.js";
+export const PAGE_STATUS = ["draft", "published", "archived"];
+export const PAGE_TYPE = [
+    "hosted_html",
+    "protected_origin",
+    "vex_artifact",
+];
+export const PAGE_VISIBILITY = ["org", "invited"];
+export function pageRenderUrl(organizationId, slug) {
+    return new URL(`/pages/${pathSegment(organizationId)}/${pathSegment(slug)}`, baseUrl()).toString();
+}

package/dist/plugins/shiftTranscription/src/index.js

@@ -0,0 +1,20 @@
+import * as t from "typebox";
+import { registerTranscriptionActions } from "./transcription.js";
+/**
+ * Shift Transcription — audio and video transcription through the
+ * Shift cloud: upload media, run jobs (optionally diarized), and read
+ * transcripts as text, subtitles, or timestamped JSON. The API key is
+ * the tenant authority; the cloud derives the organization from it
+ * (SHFT-852), so no org ID is sent.
+ */
+export default function shiftTranscription(rl) {
+    rl.setName("shiftTranscription");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            description: "Shift Labs API key",
+            env: "SHIFT_LABS_API_KEY",
+        }),
+    }));
+    registerTranscriptionActions(rl);
+}

package/dist/plugins/shiftTranscription/src/shared.js

@@ -0,0 +1,3 @@
+export { enumSchema, pathSegment, request, } from "../../_shared/shiftCloud.js";
+export const TRANSCRIPTION_LANGUAGE = ["auto", "en", "he"];
+export const TRANSCRIPT_FORMAT = ["txt", "srt", "vtt", "json"];

package/dist/plugins/{shiftLabs → shiftTranscription}/src/transcription.js

@@ -1,50 +1,10 @@
-import { openAsBlob } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
-import { extname } from "node:path";
 import * as t from "typebox";
+import { AUDIO_VIDEO_MEDIA_TYPES, putThroughGrant, requireMediaType, SIGNED_UPLOAD_MAX_BYTES, statUploadFile, } from "../../_shared/shiftUpload.js";
 import { enumSchema, pathSegment, request, TRANSCRIPT_FORMAT, TRANSCRIPTION_LANGUAGE, } from "./shared.js";
-const MEDIA_TYPES = {
-    aac: "audio/aac",
-    flac: "audio/flac",
-    m4a: "audio/m4a",
-    mov: "video/quicktime",
-    mp3: "audio/mpeg",
-    mp4: "video/mp4",
-    mpeg: "video/mpeg",
-    mpg: "video/mpeg",
-    oga: "audio/ogg",
-    ogg: "audio/ogg",
-    opus: "audio/ogg",
-    wav: "audio/wav",
-    wave: "audio/wav",
-    webm: "video/webm",
-};
-/** Mirrors the public service contract's 5 GiB source-object ceiling. */
-const MAX_MEDIA_BYTES = 5 * 1024 * 1024 * 1024;
 /** Transcript previews returned into the sandbox are capped, not truncated silently. */
 const MAX_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
 const STRICT_OBJECT = { additionalProperties: false };
 const Id = t.String({ minLength: 1, pattern: "\\S" });
-function mediaTypeFor(path) {
-    const mediaType = MEDIA_TYPES[extname(path).slice(1).toLowerCase()];
-    if (!mediaType) {
-        throw new Error(`Unsupported media extension for ${path}. Supported: ${Object.keys(MEDIA_TYPES).join(", ")}`);
-    }
-    return mediaType;
-}
-async function fileBody(path, sizeBytes) {
-    try {
-        return await openAsBlob(path);
-    }
-    catch {
-        // Runtimes without fs.openAsBlob fall back to buffering; refuse to
-        // buffer files that would strain the host process.
-        if (sizeBytes > 512 * 1024 * 1024) {
-            throw new Error("This runtime cannot stream uploads and the file is too large to buffer.");
-        }
-        return await readFile(path);
-    }
-}
 export function registerTranscriptionActions(rl) {
     rl.registerAction("transcription.transcribe", {
         access: "write",
@@ -68,6 +28,9 @@ export function registerTranscriptionActions(rl) {
                 pattern: "\\S",
                 description: "Label shown in Shift Cloud",
             })),
+            metadata: t.Optional(t.Record(t.String(), t.Unknown(), {
+                description: "Small caller-defined metadata object stored on the job",
+            })),
             waitSeconds: t.Optional(t.Number({
                 minimum: 0,
                 maximum: 120,
@@ -76,35 +39,17 @@ export function registerTranscriptionActions(rl) {
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
-            const contentType = mediaTypeFor(fields.path);
-            const file = await stat(fields.path);
-            if (!file.isFile())
-                throw new Error(`${fields.path} is not a file`);
-            if (file.size === 0)
-                throw new Error("Media file is empty");
-            if (file.size > MAX_MEDIA_BYTES) {
-                throw new Error(`Media file is larger than the ${MAX_MEDIA_BYTES}-byte service limit`);
-            }
+            const contentType = requireMediaType(fields.path, AUDIO_VIDEO_MEDIA_TYPES);
+            const sizeBytes = await statUploadFile(fields.path, SIGNED_UPLOAD_MAX_BYTES, "Media file");
             const created = await request(ctx, "/v1/services/transcription/assets", {
                 method: "POST",
                 // The API key is the tenant authority; no organizationId is sent.
                 body: JSON.stringify({
                     contentType,
-                    sizeBytes: file.size,
+                    sizeBytes,
                 }),
             });
-            const uploadHeaders = new Headers(created.upload.headers);
-            if (!uploadHeaders.has("content-type")) {
-                uploadHeaders.set("content-type", contentType);
-            }
-            const upload = await fetch(created.upload.url, {
-                method: created.upload.method,
-                headers: uploadHeaders,
-                body: await fileBody(fields.path, file.size),
-            });
-            if (!upload.ok) {
-                throw new Error(`Media upload failed: HTTP ${upload.status}`);
-            }
+            await putThroughGrant(created.upload, fields.path, contentType, sizeBytes, "Media upload");
             await request(ctx, `/v1/services/transcription/assets/${pathSegment(created.asset.id)}/complete`, { method: "POST" });
             const job = await request(ctx, "/v1/services/transcription/jobs", {
                 method: "POST",
@@ -113,6 +58,7 @@ export function registerTranscriptionActions(rl) {
                     language: fields.language,
                     diarize: fields.diarize,
                     name: fields.name,
+                    metadata: fields.metadata,
                 }),
             });
             if (!fields.waitSeconds)
@@ -151,10 +97,10 @@ export function registerTranscriptionActions(rl) {
     rl.registerAction("transcription.artifact.list", {
         access: "read",
         description: "List the available transcript artifacts for a job.",
-        inputSchema: t.Object({ jobId: Id }, STRICT_OBJECT),
+        inputSchema: t.Object({ id: Id }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { jobId } = input;
-            const body = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(jobId)}/artifacts`);
+            const { id } = input;
+            const body = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(id)}/artifacts`);
             return body.artifacts;
         },
     });
@@ -164,14 +110,14 @@ export function registerTranscriptionActions(rl) {
             "return subtitles; json returns the full timestamped document. Set " +
             "downloadOnly=true to return the short-lived signed download grant.",
         inputSchema: t.Object({
-            jobId: Id,
+            id: Id,
             format: t.Optional(enumSchema("Transcript format", [...TRANSCRIPT_FORMAT])),
             downloadOnly: t.Optional(t.Boolean({ description: "Return a signed download grant only" })),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
             const format = fields.format ?? "txt";
-            const grant = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(fields.jobId)}/artifacts/${pathSegment(format)}/download`, { method: "POST" });
+            const grant = await request(ctx, `/v1/services/transcription/jobs/${pathSegment(fields.id)}/artifacts/${pathSegment(format)}/download`, { method: "POST" });
             if (fields.downloadOnly ||
                 grant.artifact.sizeBytes > MAX_TRANSCRIPT_BYTES) {
                 return { format, ...grant };

package/dist/plugins/{shiftLabs → shiftWork}/src/index.js

@@ -1,16 +1,17 @@
 import * as t from "typebox";
 import { registerIssueViewActions } from "./issue-views.js";
 import { registerIssueActions } from "./issues.js";
-import { registerObjectActions } from "./objects.js";
-import { registerPageActions } from "./pages.js";
 import { registerProjectActions } from "./projects.js";
-import { registerTranscriptionActions } from "./transcription.js";
-export default function shiftLabs(rl) {
-    rl.setName("shiftLabs");
+/**
+ * Shift Work — the work-tracking domain of the Shift cloud: Projects,
+ * Issues (with dependencies and comments), and saved Issue Views.
+ * The API key is the tenant authority for every action; the cloud
+ * derives the organization from it (SHFT-852), so no org ID is sent.
+ */
+export default function shiftWork(rl) {
+    rl.setName("shiftWork");
     rl.setVersion("0.1.0");
     rl.setConnectionSchema(t.Object({
-        // The API key is the tenant authority for every action; the cloud
-        // derives the organization from it (SHFT-852), so no org ID is needed.
         apiKey: t.String({
             description: "Shift Labs API key",
             env: "SHIFT_LABS_API_KEY",
@@ -19,7 +20,4 @@ export default function shiftLabs(rl) {
     registerProjectActions(rl);
     registerIssueActions(rl);
     registerIssueViewActions(rl);
-    registerPageActions(rl);
-    registerTranscriptionActions(rl);
-    registerObjectActions(rl);
 }

package/dist/plugins/{shiftLabs → shiftWork}/src/issue-views.js

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { cursorSchema, enumSchema, ISSUE_PRIORITY, ISSUE_STATUS, ISSUE_VIEW_GROUP, ISSUE_VIEW_LAYOUT, ISSUE_VIEW_SORT, ISSUE_VIEW_VISIBILITY, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "./shared.js";
+import { cursorSchema, enumSchema, ISSUE_PRIORITY, ISSUE_STATUS, ISSUE_VIEW_GROUP, ISSUE_VIEW_LAYOUT, ISSUE_VIEW_SORT, ISSUE_VIEW_VISIBILITY, idSchema, listParams, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, withQuery, } from "./shared.js";
 const viewFields = {
     name: t.String({
         minLength: 1,
@@ -143,18 +143,6 @@ export function registerIssueViewActions(rl) {
         },
     });
 }
-function listParams(input) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries((input ?? {}))) {
-        if (value !== undefined)
-            params.set(key, String(value));
-    }
-    return params;
-}
-function withQuery(path, params) {
-    const query = params.toString();
-    return query ? `${path}?${query}` : path;
-}
 function assertDateOrder(startAfter, dueBefore) {
     if (typeof startAfter === "string" &&
         typeof dueBefore === "string" &&

package/dist/plugins/{shiftLabs → shiftWork}/src/issues.js

@@ -1,5 +1,30 @@
 import * as t from "typebox";
-import { cursorSchema, enumSchema, ISSUE_PRIORITY, ISSUE_SOURCE, ISSUE_STATUS, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "./shared.js";
+import { cursorSchema, enumSchema, ISSUE_PRIORITY, ISSUE_SOURCE, ISSUE_STATUS, idSchema, listParams, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, withQuery, } from "./shared.js";
+const issueFields = {
+    title: t.String({
+        minLength: 1,
+        maxLength: 160,
+        pattern: "\\S",
+        description: "Issue title",
+    }),
+    description: t.Optional(t.String({ maxLength: 20_000, description: "Issue description" })),
+    projectId: t.Optional(idSchema("Project ID")),
+    parentIssueId: t.Optional(idSchema("Parent Issue ID")),
+    sortOrder: t.Optional(t.Integer({ minimum: 0 })),
+    status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
+    priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
+    assigneeUserId: t.Optional(idSchema("Assignee user ID")),
+    startAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
+    dueAt: t.Optional(timestampSchema("ISO-8601 due timestamp")),
+    deploymentId: t.Optional(idSchema("Deployment ID")),
+    workspaceId: t.Optional(idSchema("Workspace ID")),
+    sessionId: t.Optional(idSchema("Session ID")),
+    traceId: t.Optional(idSchema("Trace ID")),
+    fingerprint: t.Optional(t.String({ minLength: 1, maxLength: 512, pattern: "\\S" })),
+    labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }))),
+    metadata: t.Optional(t.Record(t.String(), t.Unknown(), { description: "Issue metadata" })),
+    source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
+};
 const issueListFields = {
     status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
     projectId: t.Optional(idSchema("Project ID")),
@@ -14,25 +39,22 @@ const issueListFields = {
         description: "Max results, default 50",
     })),
 };
-function issueListParams(input) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries((input ?? {}))) {
-        if (value !== undefined)
-            params.set(key, String(value));
-    }
-    return params;
-}
-function withQuery(path, params) {
-    const query = params.toString();
-    return query ? `${path}?${query}` : path;
-}
+const eventListFields = {
+    id: idSchema("Issue ID"),
+    cursor: t.Optional(cursorSchema()),
+    limit: t.Optional(t.Integer({
+        minimum: 1,
+        maximum: 100,
+        description: "Max results, default 50",
+    })),
+};
 export function registerIssueActions(rl) {
     rl.registerAction("issue.list", {
         access: "read",
         description: "List the first page of Shift Labs Issues for the API key's organization.",
         inputSchema: t.Object(issueListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            const body = await request(ctx, `/v1/issues?${issueListParams(input)}`);
+            const body = await request(ctx, `/v1/issues?${listParams(input)}`);
             return body.issues;
         },
     });
@@ -41,7 +63,7 @@ export function registerIssueActions(rl) {
         description: "List a cursor-paginated page of Shift Labs Issues.",
         inputSchema: t.Object(issueListFields, STRICT_OBJECT),
         async execute(input, ctx) {
-            return request(ctx, `/v1/issues?${issueListParams(input)}`);
+            return request(ctx, `/v1/issues?${listParams(input)}`);
         },
     });
     rl.registerAction("issue.get", {
@@ -57,38 +79,10 @@ export function registerIssueActions(rl) {
     rl.registerAction("issue.create", {
         access: "write",
         description: "Create an Issue. Leave projectId empty for inbox work; parentIssueId requires a Project.",
-        inputSchema: t.Object({
-            title: t.String({
-                minLength: 1,
-                maxLength: 160,
-                pattern: "\\S",
-                description: "Issue title",
-            }),
-            description: t.Optional(t.String({ maxLength: 20_000, description: "Issue description" })),
-            projectId: t.Optional(idSchema("Project ID")),
-            parentIssueId: t.Optional(idSchema("Parent Issue ID")),
-            sortOrder: t.Optional(t.Integer({ minimum: 0 })),
-            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
-            priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
-            source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
-            assigneeUserId: t.Optional(idSchema("Assignee user ID")),
-            startAt: t.Optional(timestampSchema("ISO-8601 start timestamp")),
-            dueAt: t.Optional(timestampSchema("ISO-8601 due timestamp")),
-            deploymentId: t.Optional(idSchema("Deployment ID")),
-            workspaceId: t.Optional(idSchema("Workspace ID")),
-            sessionId: t.Optional(idSchema("Session ID")),
-            traceId: t.Optional(idSchema("Trace ID")),
-            fingerprint: t.Optional(t.String({ minLength: 1, maxLength: 512, pattern: "\\S" })),
-            labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64, pattern: "\\S" }))),
-            metadata: t.Optional(t.Record(t.String(), t.Unknown(), { description: "Issue metadata" })),
-        }, STRICT_OBJECT),
+        inputSchema: t.Object(issueFields, STRICT_OBJECT),
         async execute(input, ctx) {
             const fields = input;
-            if (fields.parentIssueId !== undefined &&
-                fields.projectId === undefined) {
-                throw new Error("projectId is required when parentIssueId is set");
-            }
-            assertDateOrder(fields.startAt, fields.dueAt, "Issue dueAt must not precede startAt");
+            assertIssueShape(fields);
             const body = await request(ctx, "/v1/issues", {
                 method: "POST",
                 body: JSON.stringify(fields),
@@ -96,6 +90,19 @@ export function registerIssueActions(rl) {
             return body.issue;
         },
     });
+    rl.registerAction("issue.report", {
+        access: "write",
+        description: "Report an Issue the way an agent should: source defaults to agent, " +
+            "and a repeated fingerprint folds into the existing Issue as a " +
+            "reported_again event instead of creating a duplicate.",
+        inputSchema: t.Object(issueFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const fields = input;
+            assertIssueShape(fields);
+            const body = await request(ctx, "/v1/issues/report", { method: "POST", body: JSON.stringify(fields) });
+            return body.issue;
+        },
+    });
     rl.registerAction("issue.update", {
         access: "write",
         description: "Update an Issue, including Project assignment, one-level parentage, ordering, status, dates, or assignee.",
@@ -139,6 +146,66 @@ export function registerIssueActions(rl) {
             return response.event;
         },
     });
+    rl.registerAction("issue.resolve", {
+        access: "write",
+        description: "Resolve an Issue, optionally with a closing comment recorded on the " +
+            "event timeline.",
+        inputSchema: t.Object({
+            id: idSchema("Issue ID"),
+            comment: t.Optional(t.String({
+                minLength: 1,
+                maxLength: 20_000,
+                pattern: "\\S",
+                description: "Resolution comment",
+            })),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}/resolve`, { method: "POST", body: JSON.stringify(fields) });
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.reopen", {
+        access: "write",
+        description: "Reopen a resolved or closed Issue.",
+        inputSchema: t.Object({ id: idSchema("Issue ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}/reopen`, { method: "POST" });
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.close", {
+        access: "write",
+        description: "Close an Issue without resolving it — the outcome for work that is " +
+            "abandoned rather than finished.",
+        inputSchema: t.Object({ id: idSchema("Issue ID") }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}/close`, { method: "POST" });
+            return body.issue;
+        },
+    });
+    rl.registerAction("issue.event.list", {
+        access: "read",
+        description: "List the first page of an Issue's event timeline: status changes, " +
+            "comments, assignment and dependency history, newest first.",
+        inputSchema: t.Object(eventListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            const body = await request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/events`, listParams(pagination)));
+            return body.events;
+        },
+    });
+    rl.registerAction("issue.event.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of an Issue's event timeline.",
+        inputSchema: t.Object(eventListFields, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            return request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/events`, listParams(pagination)));
+        },
+    });
     rl.registerAction("issue.dependency.list", {
         access: "read",
         description: "List the first page of blocking and blocked-by links.",
@@ -148,7 +215,7 @@ export function registerIssueActions(rl) {
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, ...pagination } = input;
-            const body = await request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/dependencies`, issueListParams(pagination)));
+            const body = await request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/dependencies`, listParams(pagination)));
             return body.dependencies;
         },
     });
@@ -162,7 +229,7 @@ export function registerIssueActions(rl) {
         }, STRICT_OBJECT),
         async execute(input, ctx) {
             const { id, ...pagination } = input;
-            return request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/dependencies`, issueListParams(pagination)));
+            return request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/dependencies`, listParams(pagination)));
         },
     });
     rl.registerAction("issue.dependency.add", {
@@ -185,16 +252,23 @@ export function registerIssueActions(rl) {
         access: "write",
         description: "Remove an Issue dependency link.",
         inputSchema: t.Object({
-            issueId: idSchema("Issue ID"),
+            id: idSchema("Issue ID"),
             dependencyId: idSchema("Dependency ID"),
         }, STRICT_OBJECT),
         async execute(input, ctx) {
-            const { issueId, dependencyId } = input;
-            await request(ctx, `/v1/issues/${pathSegment(issueId)}/dependencies/${pathSegment(dependencyId)}`, { method: "DELETE" });
+            const { id, dependencyId } = input;
+            await request(ctx, `/v1/issues/${pathSegment(id)}/dependencies/${pathSegment(dependencyId)}`, { method: "DELETE" });
             return { removed: true };
         },
     });
 }
+/** Shape rules the API enforces server-side, caught before the round-trip. */
+function assertIssueShape(fields) {
+    if (fields.parentIssueId !== undefined && fields.projectId === undefined) {
+        throw new Error("projectId is required when parentIssueId is set");
+    }
+    assertDateOrder(fields.startAt, fields.dueAt, "Issue dueAt must not precede startAt");
+}
 function assertDateOrder(start, end, message) {
     if (typeof start === "string" && typeof end === "string" && start > end) {
         throw new Error(message);

package/dist/plugins/{shiftLabs → shiftWork}/src/projects.js

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { cursorSchema, enumSchema, idSchema, PROJECT_STATUS, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "./shared.js";
+import { cursorSchema, enumSchema, idSchema, listParams, PROJECT_STATUS, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "./shared.js";
 const projectListFields = {
     status: t.Optional(enumSchema("Project status", PROJECT_STATUS)),
     leadUserId: t.Optional(idSchema("Lead user ID")),
@@ -7,14 +7,6 @@ const projectListFields = {
     cursor: t.Optional(cursorSchema()),
     limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
 };
-function listParams(input) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries((input ?? {}))) {
-        if (value !== undefined)
-            params.set(key, String(value));
-    }
-    return params;
-}
 export function registerProjectActions(rl) {
     rl.registerAction("project.list", {
         access: "read",

package/dist/plugins/{shiftLabs → shiftWork}/src/shared.js

@@ -1,8 +1,4 @@
-import { baseUrl, pathSegment } from "../../_shared/shiftCloud.js";
-export { baseUrl, cursorSchema, enumDescription, enumSchema, idSchema, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, } from "../../_shared/shiftCloud.js";
-export function pageRenderUrl(organizationId, slug) {
-    return new URL(`/pages/${pathSegment(organizationId)}/${pathSegment(slug)}`, baseUrl()).toString();
-}
+export { cursorSchema, enumDescription, enumSchema, idSchema, listParams, pathSegment, request, STRICT_OBJECT, STRICT_UPDATE_OBJECT, timestampSchema, withQuery, } from "../../_shared/shiftCloud.js";
 export const ISSUE_STATUS = [
     "backlog",
     "todo",
@@ -45,7 +41,3 @@ export const ISSUE_VIEW_SORT = [
     "dueAt",
     "updatedAt",
 ];
-export const PAGE_STATUS = ["draft", "published", "archived"];
-export const PAGE_VISIBILITY = ["org", "invited"];
-export const TRANSCRIPTION_LANGUAGE = ["auto", "en", "he"];
-export const TRANSCRIPT_FORMAT = ["txt", "srt", "vtt", "json"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runline",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Code mode for agents \u2014 turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",