@agent-native/core 0.92.11 → 0.93.0

package/corpus/templates/clips/server/lib/video-remux.ts

@@ -46,6 +46,53 @@ export interface SeekableResult {
   changed: boolean;
 }
 
+/**
+ * Build the ffmpeg command used by the explicit sparse-timeline repair path.
+ * The `fps` filter emits a constant frame rate, duplicating the most recent
+ * decoded frame across timestamp gaps while audio is mapped through and
+ * transcoded independently. H.264/AAC plus faststart gives mobile browsers a
+ * broadly playable result.
+ */
+export function timelineNormalizationFfmpegArgs(
+  inputPath: string,
+  outputPath: string,
+): string[] {
+  return [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-nostdin",
+    "-y",
+    "-fflags",
+    "+genpts",
+    "-i",
+    inputPath,
+    "-map",
+    "0:v:0",
+    "-map",
+    "0:a?",
+    "-vf",
+    "fps=30",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "veryfast",
+    "-crf",
+    "23",
+    "-pix_fmt",
+    "yuv420p",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    "-movflags",
+    "+faststart",
+    "-f",
+    "mp4",
+    outputPath,
+  ];
+}
+
 function ffmpegCommand(): string {
   if (process.env.FFMPEG_PATH) return process.env.FFMPEG_PATH;
   return resolveFfmpegStaticPath() ?? "ffmpeg";
@@ -273,6 +320,73 @@ export async function remuxWebmToSeekable(
   }
 }
 
+/**
+ * Normalize sparse or discontinuous video timestamps into a constant-frame-
+ * rate, faststart MP4. This is intentionally a full transcode rather than the
+ * normal lossless seekability repair: the fps filter must synthesize duplicate
+ * frames through source gaps so browsers keep advancing while continuous audio
+ * plays.
+ *
+ * Best-effort and non-destructive. Any missing ffmpeg support, decode/encode
+ * failure, invalid output, or audio-track loss returns the original bytes with
+ * `changed: false`; callers must not replace stored media in that case.
+ */
+export async function normalizeTimelineToMp4(input: {
+  mediaBytes: Uint8Array;
+  videoFormat: VideoFormat;
+}): Promise<SeekableResult> {
+  const unchanged: SeekableResult = {
+    bytes: input.mediaBytes,
+    changed: false,
+  };
+
+  if (input.mediaBytes.byteLength === 0) return unchanged;
+  if (!isFfmpegAvailable()) return unchanged;
+
+  const dir = await mkdtemp(join(tmpdir(), "clips-timeline-normalize-"));
+  const inputPath = join(dir, `input.${input.videoFormat}`);
+  const outputPath = join(dir, "output.mp4");
+
+  try {
+    const inputHasAudio = await probeHasAudioStream(
+      input.mediaBytes,
+      input.videoFormat,
+    );
+    await writeFile(inputPath, input.mediaBytes);
+    await withRemuxSlot(() =>
+      runFfmpeg(timelineNormalizationFfmpegArgs(inputPath, outputPath)),
+    );
+
+    const info = await stat(outputPath).catch(() => null);
+    if (!info || info.size === 0) return unchanged;
+
+    const out = new Uint8Array(await readFile(outputPath));
+    if (!hasPlayableMp4Metadata(out)) return unchanged;
+
+    if (inputHasAudio === true) {
+      const outputHasAudio = await probeHasAudioStream(out, "mp4");
+      if (outputHasAudio !== true) {
+        console.warn(
+          "[video-remux] timeline normalization dropped or could not verify audio; keeping original",
+        );
+        return unchanged;
+      }
+    }
+
+    return { bytes: out, changed: true };
+  } catch (err) {
+    console.warn(
+      "[video-remux] timeline normalization failed, keeping original",
+      {
+        err: err instanceof Error ? err.message : String(err),
+      },
+    );
+    return unchanged;
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
 /**
  * Make an MP4 start-playable by moving its `moov` atom ahead of `mdat`. Pure
  * TypeScript — no ffmpeg. Returns the original bytes when already faststarted

package/corpus/templates/clips/server/routes/api/_agent-native-background/post-finalize-worker.post.ts

@@ -0,0 +1,109 @@
+import {
+  runWithRequestContext,
+  verifyScopedAgentAccessToken,
+} from "@agent-native/core/server";
+import { eq } from "drizzle-orm";
+import {
+  defineEventHandler,
+  readBody,
+  setResponseStatus,
+  type H3Event,
+} from "h3";
+import { z } from "zod";
+
+import { ensureRecordingSeekable } from "../../../../actions/lib/ensure-seekable-video.js";
+import requestTranscript from "../../../../actions/request-transcript.js";
+import { getDb, schema } from "../../../db/index.js";
+import {
+  dispatchPostFinalizeJob,
+  POST_FINALIZE_JOB_TOKEN_KIND,
+  postFinalizeJobResourceId,
+} from "../../../lib/post-finalize-dispatch.js";
+
+const bodySchema = z.object({
+  recordingId: z.string().min(1).max(200),
+  kind: z.enum(["seekable", "transcript"]),
+  token: z.string().min(1),
+  delayMs: z.number().int().min(0).max(30_000).optional(),
+  retryAttempt: z.number().int().min(1).max(10).optional(),
+});
+
+export default defineEventHandler(async (event: H3Event) => {
+  const parsed = bodySchema.safeParse(await readBody(event).catch(() => null));
+  if (!parsed.success) {
+    setResponseStatus(event, 400);
+    return { ok: false, error: "Invalid post-finalize job" };
+  }
+
+  const { recordingId, kind, token, delayMs, retryAttempt } = parsed.data;
+  const verified = verifyScopedAgentAccessToken(token, {
+    resourceKind: POST_FINALIZE_JOB_TOKEN_KIND,
+    resourceId: postFinalizeJobResourceId(recordingId, kind),
+  });
+  if (!verified.ok) {
+    setResponseStatus(event, 401);
+    return { ok: false, error: "Invalid or expired post-finalize job token" };
+  }
+
+  const [recording] = await getDb()
+    .select({
+      id: schema.recordings.id,
+      ownerEmail: schema.recordings.ownerEmail,
+      orgId: schema.recordings.orgId,
+      status: schema.recordings.status,
+    })
+    .from(schema.recordings)
+    .where(eq(schema.recordings.id, recordingId))
+    .limit(1);
+  if (!recording) {
+    setResponseStatus(event, 404);
+    return { ok: false, error: "Recording not found" };
+  }
+  if (recording.status !== "ready") {
+    return {
+      ok: true,
+      recordingId,
+      kind,
+      skipped: true,
+      reason: `recording-${recording.status}`,
+    };
+  }
+
+  return runWithRequestContext(
+    {
+      userEmail: recording.ownerEmail,
+      orgId: recording.orgId ?? undefined,
+    },
+    async () => {
+      if (delayMs) {
+        await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+        await dispatchPostFinalizeJob({
+          recordingId,
+          kind,
+          retryAttempt,
+        });
+        return {
+          ok: true,
+          recordingId,
+          kind,
+          retryAttempt,
+          dispatchedAfterMs: delayMs,
+        };
+      }
+      if (kind === "seekable") {
+        const result = await ensureRecordingSeekable({
+          recordingId,
+          ownerEmail: recording.ownerEmail,
+        });
+        return { ok: true, kind, result };
+      }
+
+      const result = await requestTranscript.run({
+        recordingId,
+        force: true,
+        retryAttempt,
+      });
+      return { ok: true, kind, result };
+    },
+  );
+});

package/corpus/templates/clips/server/routes/api/clips-updater.json.get.ts

@@ -15,13 +15,14 @@ const GITHUB_MANIFEST_URL =
 const CACHE_TTL_MS = 5 * 60_000;
 
 // Tauri throws a red-banner error if the requesting client's target triple is
-// missing from `platforms`. We ship Universal-macOS + Windows, so the manifest
-// must always carry both — if upstream is missing either, fall back to inert
-// so no client sees a hard error.
-const REQUIRED_PLATFORM_KEYS = [
+// missing from `platforms`. We ship Universal macOS, Windows, and Linux, so the
+// manifest must always carry all targets — if upstream is incomplete, fall
+// back to inert so no client sees a hard error.
+export const REQUIRED_PLATFORM_KEYS = [
   "darwin-aarch64",
   "darwin-x86_64",
   "windows-x86_64",
+  "linux-x86_64",
 ];
 
 const INERT_PLATFORM = {
@@ -29,7 +30,7 @@ const INERT_PLATFORM = {
   signature: "updates-disabled",
 };
 
-const INERT_MANIFEST = {
+export const INERT_MANIFEST = {
   version: "0.0.0",
   notes:
     "Automatic updates are temporarily unavailable. Download the latest Clips installer from https://clips.agent-native.com/download.",
@@ -42,6 +43,8 @@ const INERT_MANIFEST = {
     "windows-x86_64-nsis": INERT_PLATFORM,
     "windows-x86_64-msi": INERT_PLATFORM,
     "windows-x86_64": INERT_PLATFORM,
+    "linux-x86_64-appimage": INERT_PLATFORM,
+    "linux-x86_64": INERT_PLATFORM,
   },
 };
 
@@ -62,7 +65,7 @@ function isManifestLike(value: unknown): value is Record<string, unknown> {
   return !!obj.platforms && typeof obj.platforms === "object";
 }
 
-function hasAllRequiredPlatforms(value: unknown): boolean {
+export function hasAllRequiredPlatforms(value: unknown): boolean {
   if (!isManifestLike(value)) return false;
   const platforms = value.platforms as Record<string, unknown> | undefined;
   if (!platforms || typeof platforms !== "object") return false;
@@ -101,11 +104,11 @@ async function getManifest(): Promise<unknown> {
       cache = { data, ts: Date.now() };
       return data;
     } catch {
-      // Cache the fallback (inert or last good) so we don't re-hit GitHub
-      // — and re-pay the 10s timeout — on every request after a failure.
-      const fallback = cache?.data ?? INERT_MANIFEST;
-      cache = { data: fallback, ts: Date.now() };
-      return fallback;
+      // A validation or network failure may serve the last good manifest (or
+      // inert fallback), but it must not make that fallback fresh again.
+      // Otherwise an incomplete release manifest can indefinitely extend the
+      // stale cache window on every failed refresh.
+      return cache?.data ?? INERT_MANIFEST;
     } finally {
       inFlight = null;
     }
@@ -113,6 +116,14 @@ async function getManifest(): Promise<unknown> {
   return inFlight;
 }
 
+export const __clipsUpdaterTest = {
+  getManifest,
+  reset() {
+    cache = null;
+    inFlight = null;
+  },
+};
+
 export default defineEventHandler(async (event) => {
   const manifest = await getManifest();
   setResponseHeaders(event, {

package/corpus/templates/clips/server/routes/api/public-recording.get.ts

@@ -39,6 +39,7 @@ import {
   normalizeTranscriptSegments,
   parseTranscriptSegments,
 } from "../../../shared/transcript-segments.js";
+import { resolveTranscriptPresentation } from "../../../shared/transcript-status.js";
 import { getDb, schema } from "../../db/index.js";
 import { resolvePlayerVideoUrl } from "../../lib/player-video-url.js";
 import {
@@ -382,6 +383,7 @@ export default defineEventHandler(async (event) => {
   // Don't leak the URL (which now carries a short-lived token) into the
   // Referer of any outbound link the share page renders.
   setResponseHeader(event, "Referrer-Policy", "no-referrer");
+  const transcriptPresentation = resolveTranscriptPresentation(transcript);
 
   return {
     recording: {
@@ -418,10 +420,10 @@ export default defineEventHandler(async (event) => {
     agentContextUrl,
     transcript: transcript
       ? {
-          status: transcript.status,
+          status: transcriptPresentation.status,
           language: transcript.language,
           fullText: transcript.fullText,
-          failureReason: transcript.failureReason,
+          failureReason: transcriptPresentation.failureReason,
           segments: transcriptSegments,
         }
       : null,

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/abort.post.ts

@@ -26,7 +26,11 @@ import {
   getEventOwnerContext,
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
-import { deleteResumableSession } from "../../../../lib/resumable-session.js";
+import {
+  deleteResumableSession,
+  getResumableSession,
+} from "../../../../lib/resumable-session.js";
+import { resolveResumableUploadProvider } from "../../../../lib/resumable-upload-provider.js";
 
 export default defineEventHandler(async (event: H3Event) => {
   const recordingId = getRouterParam(event, "recordingId");
@@ -74,11 +78,19 @@ export default defineEventHandler(async (event: H3Event) => {
     const preserveRecoveryState =
       isStoredButUnservableFinalizeError(failureReason) ||
       isStoredButUnservableFinalizeError(existing.failureReason);
+    const resumableSession = preserveRecoveryState
+      ? null
+      : await getResumableSession(recordingId).catch(() => null);
 
     // Already a terminal failure (e.g. a duplicate/retried abort call, or
-    // finalize's own failChunkAssembly already flipped it) — no-op instead of
-    // re-clearing chunk state and overwriting the original failureReason.
-    if (existing.status === "failed" && !preserveRecoveryState) {
+    // finalize's own failChunkAssembly already flipped it) — no-op unless a
+    // prior provider cleanup failure intentionally retained a resumable
+    // session for this retry.
+    if (
+      existing.status === "failed" &&
+      !preserveRecoveryState &&
+      !resumableSession
+    ) {
       return { ok: true, recordingId, alreadyFailed: true, chunksCleared: 0 };
     }
 
@@ -111,7 +123,37 @@ export default defineEventHandler(async (event: H3Event) => {
       ? 0
       : await deleteAppStateByPrefix(`recording-chunks-${recordingId}-`);
     if (!preserveRecoveryState) {
-      await deleteResumableSession(recordingId).catch(() => {});
+      if (resumableSession) {
+        const provider = await resolveResumableUploadProvider(
+          resumableSession.providerId,
+        ).catch(() => null);
+        let providerCleanupSucceeded = false;
+        try {
+          if (!provider?.resumable?.abortSession) {
+            throw new Error(
+              `Resumable upload provider ${resumableSession.providerId} cannot abort this session`,
+            );
+          }
+          await provider.resumable.abortSession({
+            sessionId: resumableSession.sessionId,
+            meta: resumableSession.meta,
+          });
+          providerCleanupSucceeded = true;
+        } catch (err) {
+          console.warn(
+            "[abort] resumable upload provider cleanup failed:",
+            err instanceof Error ? err.message : String(err),
+          );
+        }
+        // Keep the provider handle when cleanup fails so a later abort/cleanup
+        // retry can still address the multipart upload. Deleting it here would
+        // permanently orphan the provider-side session.
+        if (providerCleanupSucceeded) {
+          await deleteResumableSession(recordingId).catch(() => {});
+        }
+      } else {
+        await deleteResumableSession(recordingId).catch(() => {});
+      }
     }
     await writeAppState("refresh-signal", { ts: Date.now() });
 

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -17,7 +17,6 @@ import {
   readAppState,
   writeAppState,
 } from "@agent-native/core/application-state";
-import { getActiveFileUploadProvider } from "@agent-native/core/file-upload";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { track } from "@agent-native/core/tracking";
 import { normalizeChunkUploadNumber } from "@shared/recording-core.js";
@@ -51,6 +50,7 @@ import {
   setResumableSession,
   type StoredResumableSession,
 } from "../../../../lib/resumable-session.js";
+import { resolveResumableUploadProvider } from "../../../../lib/resumable-upload-provider.js";
 import { isStreamingUploadDisabled } from "../../../../lib/streaming-upload-mode.js";
 import {
   allowsSqlRecordingChunkScratch,
@@ -696,7 +696,9 @@ async function handleResumableChunk(
   query: Record<string, unknown>,
   ownerEmail: string,
 ) {
-  const uploadProvider = getActiveFileUploadProvider();
+  const uploadProvider = await resolveResumableUploadProvider(
+    session.providerId,
+  );
   if (!uploadProvider?.resumable) {
     setResponseStatus(event, 502);
     return { ok: false, error: "Upload storage is not configured" };
@@ -738,6 +740,12 @@ async function handleResumableChunk(
         error: `Resumable session close failed (${closeRes.status})`,
       };
     }
+    if (closeRes.updatedMeta) {
+      await setResumableSession(recordingId, {
+        ...session,
+        meta: { ...session.meta, ...closeRes.updatedMeta },
+      });
+    }
   } else {
     // Idempotent replay guard: a client retry (after a lost response) can
     // re-send a chunk we already committed. Re-PUTing it at the new offset

package/corpus/templates/clips/shared/share-loader-response.ts

@@ -0,0 +1,12 @@
+import { data } from "react-router";
+
+export const PRIVATE_SHARE_RESPONSE_HEADERS = {
+  "Cache-Control": "private, max-age=0, no-store",
+  "Referrer-Policy": "no-referrer",
+};
+
+export function privateShareLoaderData<T>(payload: T) {
+  return data(payload, {
+    headers: PRIVATE_SHARE_RESPONSE_HEADERS,
+  });
+}

package/corpus/templates/clips/shared/transcript-status.ts

@@ -0,0 +1,40 @@
+export const STALE_PENDING_TRANSCRIPT_MS = 5 * 60 * 1000;
+
+export const STALE_PENDING_TRANSCRIPT_REASON =
+  "Transcription stopped before it finished. Retry transcription to start a fresh attempt.";
+
+export function resolveTranscriptPresentation(
+  transcript:
+    | {
+        status?: string | null;
+        updatedAt?: string | null;
+        failureReason?: string | null;
+      }
+    | null
+    | undefined,
+  nowMs = Date.now(),
+): {
+  status: string | null;
+  failureReason: string | null;
+  stalePending: boolean;
+} {
+  const status = transcript?.status ?? null;
+  const failureReason = transcript?.failureReason ?? null;
+  if (status !== "pending") {
+    return { status, failureReason, stalePending: false };
+  }
+
+  const updatedAtMs = Date.parse(transcript?.updatedAt ?? "");
+  const stalePending =
+    !Number.isFinite(updatedAtMs) ||
+    nowMs - updatedAtMs >= STALE_PENDING_TRANSCRIPT_MS;
+  if (!stalePending) {
+    return { status, failureReason, stalePending: false };
+  }
+
+  return {
+    status: "failed",
+    failureReason: failureReason || STALE_PENDING_TRANSCRIPT_REASON,
+    stalePending: true,
+  };
+}

package/corpus/templates/content/.agents/skills/capture-learnings/SKILL.md

@@ -11,11 +11,14 @@ metadata:
 
 # Capture Learnings
 
-This is background knowledge, not a slash command. **Your memory index is loaded at the start of every conversation.** Use `save-memory` proactively when you learn something worth remembering.
+This is background knowledge, not a slash command. **Organization learnings and your personal memory index are loaded at the start of every conversation, including Slack/integration turns.** Capture durable context proactively when you learn something worth remembering.
 
 ## How to Read & Write Memories
 
-Memories are stored as **resources** in the SQL database (personal scope), not as files on disk.
+Memories are stored as **resources** in the SQL database, not as files on disk.
+
+- **Team/organization knowledge:** shared `LEARNINGS.md`. Read it first, merge the new fact, then write the full updated file with the `resources` tool using `scope: "shared"`. Shared scope resolves to the active organization; it must never leak to another organization in the same deployment.
+- **Personal knowledge:** `memory/MEMORY.md` plus `memory/<name>.md`, written with `save-memory`.
 
 - **Save a memory:** `save-memory --name <name> --type <type> --description "..." --content "..."`
 - **Read a memory:** `resource-read --path memory/<name>.md`
@@ -33,6 +36,14 @@ Memories are stored as **resources** in the SQL database (personal scope), not a
 
 ## When to Capture
 
+### Team and organization knowledge (`LEARNINGS.md`, shared scope)
+- Canonical destinations and workflows (for example, which Content database receives a type of Slack request)
+- Required intake fields, ownership, prioritization conventions, metric definitions, and approved terminology
+- Durable external references that the whole team needs, including the canonical page/database URL
+- Corrections or decisions that should affect every organization member's future Slack and app conversations
+
+Store the fact and a concise provenance link when available. Do not paste full private conversations, customer data, credentials, or secrets into learnings. Put stable always-on policy in shared `AGENTS.md`; put learned facts and evolving conventions in shared `LEARNINGS.md`.
+
 ### User Preferences & Memory (`user`)
 - **Tone and style** — "I prefer casual tone", "don't use emojis", "keep replies short"
 - **Personal context** — contacts, relationships, habits ("my wife's email is...", "I'm in PST timezone")
@@ -58,19 +69,21 @@ Memories are stored as **resources** in the SQL database (personal scope), not a
 - Things obvious from reading the code
 - Standard language/framework behavior
 - Temporary debugging notes
-- Anything already in AGENTS.md or skills
+- Anything already in AGENTS.md, shared LEARNINGS.md, or skills
 - Ephemeral task details (use tasks/plans instead)
 
 ## Key Rules
 
-1. **Save proactively — don't ask permission.** When you learn something, save it immediately.
-2. **One memory per topic** — e.g. `coding-style`, `project-alpha`, not one giant dump
-3. **Read before updating** — if a memory exists, read it first and merge, don't overwrite
-4. **Keep descriptions concise** — the index is loaded every conversation
-5. **Memories are SQL-backed** — safe for personal info, persist across sessions, not in git
+1. **Save proactively — don't ask permission.** When you learn something durable, save it immediately at the correct scope.
+2. **Choose scope by audience.** Organization workflow or reference → shared `LEARNINGS.md`; one person's preference/context → personal memory.
+3. **One memory per topic** — e.g. `coding-style`, `project-alpha`, not one giant dump
+4. **Read before updating** — if a memory exists, read it first and merge, don't overwrite
+5. **Keep descriptions concise** — the index is loaded every conversation
+6. **Memories are SQL-backed** — they persist across sessions and are not in git; still minimize sensitive content
 
 ## Graduation
 
 When a memory is referenced repeatedly, it may belong in AGENTS.md or a skill:
-- Saving a memory is lightweight (auto-apply, personal scope)
+- Saving a personal memory is lightweight (auto-apply, personal scope)
+- Shared LEARNINGS.md is the lightweight organization knowledge layer
 - Updating AGENTS.md or a skill is heavier (affects all users/agents)

package/corpus/templates/content/.agents/skills/content/SKILL.md

@@ -2,8 +2,9 @@
 name: content
 description: >-
   Use Content for repo-backed Markdown/MDX docs, blogs, resources, rich
-  document editing, local components, shareable copies, and Content local-file
-  workspaces. Prefer Content actions over raw filesystem writes when available.
+  document editing, Notion-style databases and boards, structured intake
+  forms, local components, shareable copies, and Content local-file workspaces.
+  Prefer Content actions over raw filesystem writes when available.
 metadata:
   visibility: exported
 ---
@@ -12,9 +13,11 @@ metadata:
 
 Use the Content app when a workflow is about authoring, editing, reviewing, or
 publishing Markdown/MDX documents: docs sites, blogs, resource libraries,
-marketing pages, internal notes, and local MDX components. Content gives the
-agent a document tree, a rich editor, normal document actions, and optional
-local-file source of truth.
+marketing pages, internal notes, and local MDX components. Also use Content for
+Notion-style databases, tables, boards, structured request intake, and forms
+whose submissions become database row pages. Content gives the agent a document
+tree, a rich editor, structured database properties and views, normal document
+actions, and an optional local-file source of truth.
 
 ## Choose The Path
 
@@ -26,6 +29,10 @@ local-file source of truth.
 - Use `pull-document` or `get-document` before editing a page. Use
   `edit-document` for precise find/replace changes and `update-document` for
   full rewrites or new content.
+- Use `list-documents` or `search-documents` to find an existing database by
+  its exact title, then inspect it with `get-content-database` before creating
+  or submitting anything. Do not create a second database when the canonical
+  one already exists.
 - In Local File Mode, Content actions read and write the repo files declared in
   `agent-native.json`; SQL remains cache/history/search glue, not the source of
   truth for those pages.
@@ -49,6 +56,51 @@ pnpm action share-local-file-document '{"id":"local-file:..."}'
 Run `refresh-list` after create/update/delete operations when you need the open
 Content UI sidebar to repaint immediately.
 
+## Database And Intake Workflows
+
+Content databases are one available capability for structured team queues,
+tables, boards, and intake forms. Select Content when workspace instructions or
+app-capability discovery identify it as the owner of the workflow. Do not route
+from a department or subject word alone, and do not embed an organization's
+queue name, destination ID, schema, required fields, or owner in this reusable
+skill. If workspace instructions assign the workflow to another app, follow
+those instructions.
+
+For a named intake workflow:
+
+1. Read the loaded workspace instruction/resource first. It may identify the
+   owning app, canonical database ID or title, form view, and intake policy.
+   Treat that live instruction as authoritative instead of applying defaults
+   from this skill.
+2. Once Content is selected, find the canonical database by the instructed ID
+   or exact title with `list-documents` or `search-documents`; inspect it with
+   `get-content-database` and, when available,
+   `get-content-database-form`. Preserve its database and document IDs. Never
+   guess IDs or create a duplicate queue.
+3. Read the current property/form schema and required fields before asking the
+   user anything. Ask only for required values that are actually missing.
+4. You may infer low-risk values from the request, sender identity, and source
+   context, but state proposed values and confirm any uncertain or consequential
+   inference. Never invent a value for a field marked required.
+5. Preserve a provided `Source Slack thread` URL verbatim in the matching URL
+   or source field. It is request provenance; never replace it with an invented
+   Slack URL.
+6. Submit exactly once with `submit-content-database-form` when that action is
+   available. Prefer it over piecemeal writes because it validates required
+   fields and verifies the saved row. Fall back to `add-database-item` only
+   when the database has no form contract and all required values have already
+   been confirmed.
+7. Treat submission as complete only when the successful result includes a
+   `createdDocumentId` and verification. Return the exact `url` or `urlPath`
+   from the result. The canonical Content row route is `/page/<createdDocumentId>`;
+   never invent a different path, slug, ID, or host.
+
+When the user supplies a complete description in one message, do not force a
+questionnaire: extract the matching fields, show only genuinely uncertain
+inferences for confirmation, then submit once. When required information is
+missing, keep the clarification in the originating thread and retain earlier
+answers as context.
+
 ## Local File Mode
 
 Install into an existing repo with: