runwork 0.24.0 → 0.25.0

package/dist/index.js

@@ -2169,7 +2169,7 @@ var init_agent_guidance = __esm(() => {
     "worker/components.ts": "Reusable UI components other workspace apps can embed.",
     "shared/types.ts": "TypeScript interfaces shared between frontend and backend.",
     "src/pages/": "Frontend React pages. Each file becomes a route.",
-    "blueprint.json": "App feature registry. Update after adding entities, workflows, agents, etc.",
+    "blueprint.json": "App feature registry. Update after adding entities, workflows, agents, etc., including each one's valueProfile (what manual work it replaced).",
     "CLAUDE.md": "Complete framework documentation. Read this before editing anything."
   };
   COMMON_TIPS = [
@@ -2180,6 +2180,7 @@ var init_agent_guidance = __esm(() => {
     "Every workflow MUST have a trigger (API endpoint, scheduled job, or UI button). Workflows without triggers are dead code.",
     "Every conversational agent MUST have a frontend page to access it.",
     "After adding entities, workflows, or agents, update blueprint.json with the new metadata.",
+    "When you add a feature that takes over manual work, ASK your human what they used to do by hand, how often THEY did it, and how long one round took, then record it as a valueProfile on that blueprint element. Set confirmedWithHuman only if they actually agreed to the numbers. If they cannot answer, omit valueProfile rather than guessing. See the valueProfile section in CLAUDE.md.",
     "Never guess integration IDs. Run: runwork integrations search <query>"
   ];
 });
@@ -5100,8 +5101,8 @@ export declare function componentRoutes(app: Hono<{
     Bindings: Env;
 }>): void;
 `,
-    "workspace.d.ts": `export { WorkspaceContext, getWorkspaceContext, listWorkspaceEntity, getWorkspaceEntity, createWorkspaceEntity, updateWorkspaceEntity, deleteWorkspaceEntity, initializeWorkspace, } from './core-workspace';
-export type { WorkspaceUser, ListUsersOptions, ListUsersResponse, NotifyUserParams, NotifyUserResult, ListEntityRequest, ListEntityResponse, GetEntityRequest, CreateEntityRequest, UpdateEntityRequest, DeleteEntityRequest, RegisterEntityRequest, RegisterAppRequest, RegisterComponentRequest, RegisterScheduleRequest, RegisterWorkflowRequest, RegisterEndpointRequest, RegisterIntegrationRequest, RegisterAgentRequest as WorkspaceRegisterAgentRequest, } from './core-workspace';
+    "workspace.d.ts": `export { WorkspaceContext, getWorkspaceContext, listWorkspaceEntity, getWorkspaceEntity, createWorkspaceEntity, updateWorkspaceEntity, deleteWorkspaceEntity, callAppEndpoint, initializeWorkspace, } from './core-workspace';
+export type { WorkspaceUser, ListUsersOptions, ListUsersResponse, NotifyUserParams, NotifyUserResult, ListEntityRequest, ListEntityResponse, GetEntityRequest, CreateEntityRequest, UpdateEntityRequest, DeleteEntityRequest, RegisterEntityRequest, RegisterAppRequest, RegisterComponentRequest, RegisterScheduleRequest, RegisterWorkflowRequest, RegisterEndpointRequest, RegisterIntegrationRequest, CallAppEndpointOptions, CallAppEndpointResult, RegisterAgentRequest as WorkspaceRegisterAgentRequest, } from './core-workspace';
 `,
     "core-scheduler.d.ts": `/**
  * Core Scheduled Jobs Framework
@@ -5443,11 +5444,16 @@ type ZodSchema = z.ZodType<any, any, any>;
 export type EndpointAuthType = 'apiKey' | 'public';
 /**
  * Caller principal type resolved by the platform and passed via the
- * \`X-Public-Endpoint-Auth-Type\` header. \`user\` and \`workspace_key\` are
+ * \`X-Public-Endpoint-Auth-Type\` header. \`user\`, \`workspace_key\` and \`app\` are
  * authenticated principals the platform has already authorized; \`api_key\`
  * additionally carries a validated key id; \`none\` is unauthenticated.
+ *
+ * \`app\` means a sibling app in the same workspace called this endpoint through
+ * the platform (see \`callAppEndpoint\`). The platform records which app made the
+ * call, but does not forward that id here: it is self-asserted by the caller and
+ * must not be used for authorization until app identity is verifiable.
  */
-export type EndpointPrincipalType = 'none' | 'api_key' | 'workspace_key' | 'user';
+export type EndpointPrincipalType = 'none' | 'api_key' | 'workspace_key' | 'user' | 'app';
 /**
  * HTTP methods supported by endpoints
  */
@@ -5490,7 +5496,7 @@ export interface EndpointContext<TQuery = Record<string, unknown>, TBody = unkno
 export interface EndpointAuthInfo {
     /** Authentication requirement declared by the endpoint */
     type: EndpointAuthType;
-    /** Resolved caller principal type (api_key, workspace_key, user, none) */
+    /** Resolved caller principal type (api_key, workspace_key, user, app, none) */
     principalType?: EndpointPrincipalType;
     /** API key ID (if authenticated with an API key) */
     apiKeyId?: string;
@@ -6319,6 +6325,34 @@ export interface RegisterAgentRequest extends Record<string, unknown> {
  * WorkspaceContext - Helper for cross-app data queries
  * Provides methods to query entities from other apps in the same workspace
  */
+/**
+ * Options for calling a public endpoint on another app in the workspace.
+ */
+export interface CallAppEndpointOptions {
+    /**
+     * Target app, normally its slug as shown in the dashboard (e.g. 'labcrm').
+     * An app id or worker name also resolves. If the slug is wrong, the error
+     * response lists the slugs available in this workspace.
+     */
+    app: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Endpoint path exactly as registered, path params included: '/v1/orders/:id'. */
+    path: string;
+    /** Values for the \`:param\` segments in \`path\`. */
+    pathParams?: Record<string, string>;
+    queryParams?: Record<string, string>;
+    /** JSON body. Ignored for GET and HEAD. */
+    body?: unknown;
+}
+/**
+ * Result of a cross-app endpoint call. \`ok\` and \`status\` are the target
+ * endpoint's own response status, not the transport's.
+ */
+export interface CallAppEndpointResult<T = unknown> {
+    ok: boolean;
+    status: number;
+    data: T;
+}
 export declare class WorkspaceContext {
     private env;
     private workspaceId;
@@ -6355,6 +6389,45 @@ export declare class WorkspaceContext {
      * Delete an entity in another app in the workspace
      */
     deleteEntity(entityName: string, id: string): Promise<void>;
+    /**
+     * Transport for cross-app endpoint calls.
+     *
+     * Deliberately NOT \`workspaceFetch\`, for two reasons:
+     *
+     * 1. \`workspaceFetch\` retries over HTTP whenever the Durable Object returns a
+     *    non-2xx. That is right for entity CRUD, where a non-2xx means the DO
+     *    itself failed. Here a non-2xx is the TARGET ENDPOINT'S OWN ANSWER, so
+     *    retrying would re-send the request — duplicating POSTs — and in production
+     *    the retry goes to the platform's own domain, which a Workers for Platforms
+     *    worker cannot fetch: it hangs until timeout, the very failure this function
+     *    exists to avoid. A status is a result, never a transport error.
+     *
+     * 2. Production therefore uses the DO binding ONLY, mirroring \`workspaceApiFetch\`
+     *    in core-utils.ts, which is the proven path for every other platform call
+     *    made from a deployed app. Preview and sandbox keep the HTTP path, where the
+     *    app is reached over a tunnel rather than the dispatch namespace.
+     */
+    private endpointCallFetch;
+    /**
+     * Call a public endpoint on another app in this workspace.
+     *
+     * Production apps run in a Workers for Platforms dispatch namespace and cannot
+     * HTTP-fetch the platform's app domain, so a direct \`fetch()\` to a sibling app's
+     * public URL hangs until it times out. This routes through the workspace instead,
+     * which reaches the target app via the dispatcher.
+     *
+     * The call arrives at the target as an \`app\` principal, which satisfies endpoints
+     * declared \`auth: 'apiKey'\`. No API key is needed or sent.
+     *
+     * @example
+     * const invite = await callAppEndpoint(env, {
+     *   app: 'labcrm',
+     *   method: 'GET',
+     *   path: '/v1/portal/invite/:token',
+     *   pathParams: { token },
+     * });
+     */
+    callAppEndpoint<T = unknown>(options: CallAppEndpointOptions): Promise<CallAppEndpointResult<T>>;
     /**
      * Register an entity with the workspace so other apps can query it
      */
@@ -6587,6 +6660,22 @@ export declare function listWorkspaceEntity<T = unknown>(env: Env, entityName: s
  * @example
  * const contact = await getWorkspaceEntity<Contact>(env, 'Contact', 'contact-123');
  */
+/**
+ * Call a public endpoint on ANOTHER app in this workspace.
+ *
+ * Use this instead of \`fetch()\` against a sibling app's public URL: production apps
+ * cannot HTTP-fetch the platform's app domain and such a fetch hangs until timeout.
+ *
+ * @example
+ * const result = await callAppEndpoint(env, {
+ *   app: 'labcrm',
+ *   method: 'POST',
+ *   path: '/v1/portal/orders',
+ *   body: { items },
+ * });
+ * if (!result.ok) throw new Error(\`CRM rejected the order: \${result.status}\`);
+ */
+export declare function callAppEndpoint<T = unknown>(env: Env, options: CallAppEndpointOptions): Promise<CallAppEndpointResult<T>>;
 export declare function getWorkspaceEntity<T = unknown>(env: Env, entityName: string, id: string): Promise<T | null>;
 /**
  * Create an entity in ANOTHER app in the workspace (cross-app ONLY)
@@ -6914,6 +7003,13 @@ export declare class BaseAgent extends AIChatAgent<Env> {
      * Build tools for accessing entities using AI SDK tool() helper
      * Uses entity classes directly with EntityContext
      */
+    /**
+     * One tool per endpoint the agent is allowed to call on another app.
+     *
+     * Routed through \`callAppEndpoint\`, so it works in preview and production
+     * alike: a production app cannot HTTP-fetch a sibling's public URL.
+     */
+    private buildAppEndpointTools;
     private buildEntityTools;
     /**
      * Build tools for running complex tasks via a sandboxed AI sub-agent
@@ -7353,6 +7449,16 @@ export interface AgentDefinition {
     integrations?: string[];
     /** Entity names the agent can read/write */
     entities?: string[];
+    /**
+     * Endpoints on OTHER apps in this workspace that the agent may call, as
+     * \`'<app>:<METHOD>:<path>'\` — e.g. \`'labcrm:GET:/v1/portal/catalog'\`.
+     * \`<app>\` is the target app's slug; \`<path>\` is the path exactly as registered,
+     * \`:param\` placeholders included.
+     *
+     * Declared explicitly, like \`entities\` and \`integrations\`: an agent can only
+     * call what the app author listed, never an arbitrary endpoint.
+     */
+    appEndpoints?: string[];
     /** Memory strategy */
     memoryStrategy?: MemoryStrategy;
     /** Custom tools for this agent */
@@ -7362,6 +7468,27 @@ export interface AgentDefinition {
     /** Cost/time limits for task agent sandbox execution. Optional overrides. */
     executionLimits?: ExecutionLimits;
 }
+/** A parsed \`'<app>:<METHOD>:<path>'\` agent endpoint reference. */
+export interface AppEndpointRef {
+    app: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+}
+/**
+ * Parse \`'labcrm:GET:/v1/portal/invite/:token'\`.
+ *
+ * Split on the first two colons only: the path itself contains colons for its
+ * \`:param\` segments, so a naive split would mangle every parameterized endpoint.
+ * Returns null for anything malformed rather than throwing, so one bad entry in an
+ * agent definition costs that one tool instead of the whole agent.
+ */
+export declare function parseAppEndpointRef(ref: string): AppEndpointRef | null;
+/**
+ * Stable, model-friendly tool name for an endpoint reference, e.g.
+ * \`call_labcrm_get_v1_portal_invite\`. Param segments are dropped so the name
+ * stays readable; the full path is in the tool description.
+ */
+export declare function appEndpointToolName(ref: AppEndpointRef): string;
 /**
  * Custom tool definition for agents
  */
@@ -7713,7 +7840,7 @@ function createKeyboardListener() {
 }
 
 // src/generated/version.ts
-var VERSION = "0.24.0";
+var VERSION = "0.25.0";
 
 // src/commands/dev.ts
 var exports_dev = {};
@@ -8762,10 +8889,19 @@ function saveDefaultWorkspace(workspaceId, workspaceName) {
 function hasProjectConfig() {
   return existsSync21(".runwork.json");
 }
+function matchAppRef(apps, ref) {
+  return apps.find((a) => a.id === ref || a.name === ref || a.slug === ref);
+}
+function filterRowsByApp(rows, appRef, apps) {
+  const match = matchAppRef(apps, appRef);
+  if (!match)
+    return null;
+  return rows.filter((row) => row.appId === match.id);
+}
 async function resolveApp2(client, workspaceId, options = {}) {
   if (options.app) {
     const apps = await client.listApps(workspaceId);
-    const match = apps.find((a) => a.id === options.app || a.name === options.app || a.slug === options.app);
+    const match = matchAppRef(apps, options.app);
     if (!match) {
       console.error(`App "${options.app}" not found in workspace.`);
       process.exit(1);
@@ -9612,6 +9748,187 @@ var init_registry = __esm(() => {
 });
 
 // src/agents/utils/session-digest.ts
+function emptyGapBuckets() {
+  return { lt10s: 0, s10to30: 0, s30to2m: 0, m2to5: 0, m5to15: 0, gte15m: 0 };
+}
+function gapBucketKey(seconds) {
+  if (seconds < 10)
+    return "lt10s";
+  if (seconds < 30)
+    return "s10to30";
+  if (seconds < 120)
+    return "s30to2m";
+  if (seconds < 300)
+    return "m2to5";
+  if (seconds < 900)
+    return "m5to15";
+  return "gte15m";
+}
+function buildGapHistogram(epochMs) {
+  const ts = epochMs.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+  if (ts.length < 2)
+    return null;
+  const gapCounts = emptyGapBuckets();
+  const gapSeconds = emptyGapBuckets();
+  let longest = 0;
+  for (let i = 1;i < ts.length; i++) {
+    const gap = (ts[i] - ts[i - 1]) / 1000;
+    const key = gapBucketKey(gap);
+    gapCounts[key]++;
+    gapSeconds[key] += gap;
+    if (gap > longest)
+      longest = gap;
+  }
+  for (const key of Object.keys(gapSeconds)) {
+    gapSeconds[key] = Math.round(gapSeconds[key]);
+  }
+  return {
+    gapCounts,
+    gapSeconds,
+    spanMinutes: Math.round((ts[ts.length - 1] - ts[0]) / 6000) / 10,
+    longestGapSeconds: Math.round(longest)
+  };
+}
+function emptySessionSignals() {
+  return {
+    provenance: null,
+    gapCounts: null,
+    gapSeconds: null,
+    spanMinutes: null,
+    longestGapSeconds: null,
+    permissionModes: null,
+    modeEscalations: null,
+    approvalPolicy: null,
+    sandboxPolicy: null,
+    subagentCount: null,
+    planModeUsed: null,
+    slashCommandCount: null,
+    modelInitiatedSkillCount: null,
+    promptLengthBuckets: null,
+    toolFailureStreakMax: null,
+    repeatedCallMax: null,
+    models: null,
+    tokens: null,
+    tokensByModel: null
+  };
+}
+function applyGapHistogram(signals, epochMs) {
+  const h = buildGapHistogram(epochMs);
+  if (!h)
+    return;
+  signals.gapCounts = h.gapCounts;
+  signals.gapSeconds = h.gapSeconds;
+  signals.spanMinutes = h.spanMinutes;
+  signals.longestGapSeconds = h.longestGapSeconds;
+}
+function promptLengthBucket(len) {
+  if (len < 120)
+    return "short";
+  if (len <= 600)
+    return "medium";
+  return "long";
+}
+function classifyClaudeProvenance(obj) {
+  const entrypoint = typeof obj.entrypoint === "string" ? obj.entrypoint : null;
+  const promptSource = typeof obj.promptSource === "string" ? obj.promptSource : null;
+  const originKind = obj.origin?.kind ?? null;
+  if (entrypoint === "sdk-cli" || entrypoint === "sdk-ts")
+    return "headless";
+  if (promptSource === "sdk")
+    return "headless";
+  if (originKind !== null && originKind !== "human")
+    return "agent-spawned";
+  if (entrypoint === "cli" || entrypoint === "claude-desktop" || entrypoint === "local-agent")
+    return "user-driven";
+  if (originKind === "human" || promptSource === "typed")
+    return "user-driven";
+  return null;
+}
+function sumTokenTotals(byModel) {
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let cacheReadTokens = null;
+  let cacheCreationTokens = null;
+  for (const t of byModel.values()) {
+    tokensIn += t.tokensIn;
+    tokensOut += t.tokensOut;
+    if (t.cacheReadTokens !== null)
+      cacheReadTokens = (cacheReadTokens ?? 0) + t.cacheReadTokens;
+    if (t.cacheCreationTokens !== null)
+      cacheCreationTokens = (cacheCreationTokens ?? 0) + t.cacheCreationTokens;
+  }
+  return { tokensIn, tokensOut, cacheReadTokens, cacheCreationTokens };
+}
+function applyTokenMap(signals, byModel) {
+  if (byModel.size === 0)
+    return;
+  signals.models = [...byModel.keys()];
+  signals.tokens = sumTokenTotals(byModel);
+  signals.tokensByModel = Object.fromEntries(byModel);
+}
+function stableStringify(value) {
+  if (Array.isArray(value))
+    return "[" + value.map(stableStringify).join(",") + "]";
+  if (value && typeof value === "object") {
+    return "{" + Object.keys(value).sort().map((k) => JSON.stringify(k) + ":" + stableStringify(value[k])).join(",") + "}";
+  }
+  return JSON.stringify(value) ?? "undefined";
+}
+
+class FrictionCounters {
+  failStreak = 0;
+  failStreakMax = 0;
+  callCounts = new Map;
+  repeatedCallMax = 0;
+  result(failed) {
+    if (failed) {
+      this.failStreak++;
+      if (this.failStreak > this.failStreakMax)
+        this.failStreakMax = this.failStreak;
+    } else {
+      this.failStreak = 0;
+    }
+  }
+  call(name, args) {
+    const key = name + "\x00" + stableStringify(args ?? null);
+    const n = (this.callCounts.get(key) ?? 0) + 1;
+    this.callCounts.set(key, n);
+    if (n > this.repeatedCallMax)
+      this.repeatedCallMax = n;
+  }
+}
+function recordAssetAttempt(acc, rawName, epochMs, turnsBefore, toolCallsBefore) {
+  const existing = acc.get(rawName);
+  if (existing) {
+    existing.attempts++;
+    return;
+  }
+  acc.set(rawName, { firstEpochMs: epochMs, attempts: 1, turnsBefore, toolCallsBefore });
+}
+function buildAssetMarkers(acc, epochMs) {
+  if (acc.size === 0)
+    return;
+  const sorted = epochMs.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+  const start = sorted[0];
+  const markers = [];
+  for (const [rawName, m] of acc) {
+    const first = m.firstEpochMs;
+    const histogram = first !== null ? buildGapHistogram(sorted.filter((ms) => ms <= first)) : null;
+    markers.push({
+      kind: "skill",
+      rawName,
+      attempts: m.attempts,
+      turnsBefore: m.turnsBefore,
+      toolCallsBefore: m.toolCallsBefore,
+      wallSecondsToAsset: first !== null && sorted.length > 0 ? Math.round((first - start) / 1000) : null,
+      gapCountsToAsset: histogram?.gapCounts ?? null,
+      gapSecondsToAsset: histogram?.gapSeconds ?? null
+    });
+    if (markers.length >= 8)
+      break;
+  }
+  return markers;
+}
 function extractClaudeJsonlSession(raw, agentSlug, project) {
   const digest = {
     agentSlug,
@@ -9625,6 +9942,21 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
     errorCount: 0,
     assistantTurns: 0
   };
+  const signals = emptySessionSignals();
+  const epochMs = [];
+  const modeStream = [];
+  let subagentCount = 0;
+  let planToolSeen = false;
+  let slashCommandCount = 0;
+  let modelInitiatedSkillCount = 0;
+  const promptBuckets = { short: 0, medium: 0, long: 0 };
+  const tokensByModel = new Map;
+  const seenUsagePairs = new Set;
+  let provenanceClassified = false;
+  let sidechainUserSeen = false;
+  let toolCallsSeen = 0;
+  const assetAcc = new Map;
+  const friction = new FrictionCounters;
   for (const line of raw.split(`
 `)) {
     if (!line.trim())
@@ -9640,12 +9972,29 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
       if (!digest.start)
         digest.start = ts;
       digest.end = ts;
+      const ms = Date.parse(ts);
+      if (Number.isFinite(ms))
+        epochMs.push(ms);
     }
     const type = obj.type;
+    if (type === "permission-mode" && typeof obj.permissionMode === "string") {
+      modeStream.push(obj.permissionMode);
+      continue;
+    }
     const message = obj.message;
     if (!message || typeof message !== "object")
       continue;
     if (type === "user" && message.role === "user") {
+      if (obj.isSidechain === true)
+        sidechainUserSeen = true;
+      else if (!provenanceClassified) {
+        provenanceClassified = true;
+        signals.provenance = classifyClaudeProvenance(obj);
+      }
+      if (typeof obj.permissionMode === "string")
+        modeStream.push(obj.permissionMode);
+      const originKind = obj.origin?.kind;
+      const humanLine = obj.isSidechain !== true && (originKind === undefined || originKind === "human");
       const texts = [];
       if (typeof message.content === "string") {
         texts.push(message.content);
@@ -9655,15 +10004,22 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
             const it = item;
             if (it.type === "text" && typeof it.text === "string")
               texts.push(it.text);
-            if (it.type === "tool_result" && it.is_error === true)
-              digest.errorCount++;
+            if (it.type === "tool_result") {
+              if (it.is_error === true)
+                digest.errorCount++;
+              friction.result(it.is_error === true);
+            }
           }
         }
       }
       for (const text2 of texts) {
         const trimmed = text2.trim();
+        if (trimmed.startsWith("<command-name>"))
+          slashCommandCount++;
         if (!trimmed || SKIP_PREFIXES.some((p) => trimmed.startsWith(p)))
           continue;
+        if (humanLine)
+          promptBuckets[promptLengthBucket(trimmed.length)]++;
         if (digest.userMessages.length >= MAX_MSGS_PER_SESSION) {
           digest.droppedUserMessages++;
           continue;
@@ -9671,15 +10027,47 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
         digest.userMessages.push(trimmed.length > MAX_MSG_CHARS ? trimmed.slice(0, MAX_MSG_CHARS) + " [...]" : trimmed);
       }
     }
-    if (type === "assistant" && message.role === "assistant" && Array.isArray(message.content)) {
+    if (type === "assistant" && message.role === "assistant") {
+      const am = message;
+      const model = typeof am.model === "string" ? am.model : null;
+      const usage = am.usage;
+      if (usage && typeof usage === "object" && model && model !== "<synthetic>") {
+        const requestId = typeof obj.requestId === "string" ? obj.requestId : null;
+        const pairKey = typeof am.id === "string" && requestId ? `${am.id}:${requestId}` : null;
+        if (!pairKey || !seenUsagePairs.has(pairKey)) {
+          if (pairKey)
+            seenUsagePairs.add(pairKey);
+          const t = tokensByModel.get(model) ?? { tokensIn: 0, tokensOut: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
+          t.tokensIn += finiteNum(usage.input_tokens);
+          t.tokensOut += finiteNum(usage.output_tokens);
+          t.cacheReadTokens = (t.cacheReadTokens ?? 0) + finiteNum(usage.cache_read_input_tokens);
+          t.cacheCreationTokens = (t.cacheCreationTokens ?? 0) + finiteNum(usage.cache_creation_input_tokens);
+          tokensByModel.set(model, t);
+        }
+      }
+      if (!Array.isArray(message.content))
+        continue;
       digest.assistantTurns++;
       for (const item of message.content) {
         if (item && typeof item === "object") {
           const it = item;
           if (it.type === "tool_use" && typeof it.name === "string") {
             digest.toolCounts[it.name] = (digest.toolCounts[it.name] ?? 0) + 1;
-            if (it.name === "Skill" && it.input?.skill)
-              digest.skillInvocations.push(it.input.skill);
+            friction.call(it.name, it.input);
+            if (it.name === "Agent" || it.name === "Task")
+              subagentCount++;
+            if (it.name === "EnterPlanMode" || it.name === "ExitPlanMode")
+              planToolSeen = true;
+            if (it.name === "Skill") {
+              modelInitiatedSkillCount++;
+              if (it.input?.skill)
+                digest.skillInvocations.push(it.input.skill);
+            }
+            if (it.name.endsWith("__save_skill") && typeof it.input?.name === "string" && it.input.name.trim()) {
+              const ms = ts ? Date.parse(ts) : NaN;
+              recordAssetAttempt(assetAcc, it.input.name.trim(), Number.isFinite(ms) ? ms : null, Math.max(0, digest.assistantTurns - 1), toolCallsSeen);
+            }
+            toolCallsSeen++;
           }
         }
       }
@@ -9687,11 +10075,40 @@ function extractClaudeJsonlSession(raw, agentSlug, project) {
   }
   if (digest.userMessages.length === 0)
     return null;
+  if (!provenanceClassified && sidechainUserSeen)
+    signals.provenance = "agent-spawned";
+  applyGapHistogram(signals, epochMs);
+  const collapsed = modeStream.filter((m, i) => i === 0 || m !== modeStream[i - 1]);
+  signals.permissionModes = collapsed.length > 0 ? [...new Set(collapsed)] : null;
+  signals.modeEscalations = collapsed.length > 0 ? collapsed.length - 1 : null;
+  signals.subagentCount = subagentCount;
+  signals.planModeUsed = planToolSeen || collapsed.includes("plan");
+  signals.slashCommandCount = slashCommandCount;
+  signals.modelInitiatedSkillCount = modelInitiatedSkillCount;
+  signals.promptLengthBuckets = promptBuckets;
+  signals.toolFailureStreakMax = friction.failStreakMax;
+  signals.repeatedCallMax = friction.repeatedCallMax;
+  applyTokenMap(signals, tokensByModel);
+  digest.signals = signals;
+  digest.assetMarkers = buildAssetMarkers(assetAcc, epochMs);
   return digest;
 }
 function decodeProjectDir(encoded) {
   return encoded.replace(/^-/, "/").replace(/-/g, "/");
 }
+function classifyCodexProvenance(meta) {
+  const source = meta.source;
+  const originator = typeof meta.originator === "string" ? meta.originator : null;
+  if (source && typeof source === "object" && "subagent" in source)
+    return "agent-spawned";
+  if (originator === "Claude Code")
+    return "agent-spawned";
+  if (source === "exec")
+    return "headless";
+  if (source === "cli" || source === "vscode")
+    return "user-driven";
+  return null;
+}
 function geminiMessageText(content) {
   if (typeof content === "string")
     return content;
@@ -9727,6 +10144,9 @@ function extractGeminiSession(raw, agentSlug, project) {
     digest.start = session.startTime;
   if (typeof session.lastUpdated === "string")
     digest.end = session.lastUpdated;
+  const signals = emptySessionSignals();
+  const epochMs = [];
+  const tokensByModel = new Map;
   for (const raw2 of session.messages) {
     const m = raw2;
     if (typeof m.timestamp === "string") {
@@ -9734,9 +10154,21 @@ function extractGeminiSession(raw, agentSlug, project) {
         digest.start = m.timestamp;
       if (!digest.end || m.timestamp > digest.end)
         digest.end = m.timestamp;
+      const ms = Date.parse(m.timestamp);
+      if (Number.isFinite(ms))
+        epochMs.push(ms);
     }
     if (m.type === "gemini") {
       digest.assistantTurns++;
+      const tok = m.tokens;
+      if (tok && typeof tok === "object") {
+        const model = typeof m.model === "string" ? m.model : "unknown";
+        const t = tokensByModel.get(model) ?? { tokensIn: 0, tokensOut: 0, cacheReadTokens: 0, cacheCreationTokens: null };
+        t.tokensIn += finiteNum(tok.input);
+        t.tokensOut += finiteNum(tok.output) + finiteNum(tok.thoughts);
+        t.cacheReadTokens = (t.cacheReadTokens ?? 0) + finiteNum(tok.cached);
+        tokensByModel.set(model, t);
+      }
       continue;
     }
     if (m.type === "error") {
@@ -9754,7 +10186,12 @@ function extractGeminiSession(raw, agentSlug, project) {
     }
     digest.userMessages.push(text2.length > MAX_MSG_CHARS ? `${text2.slice(0, MAX_MSG_CHARS)}...` : text2);
   }
-  return digest.userMessages.length > 0 ? digest : null;
+  if (digest.userMessages.length === 0)
+    return null;
+  applyGapHistogram(signals, epochMs);
+  applyTokenMap(signals, tokensByModel);
+  digest.signals = signals;
+  return digest;
 }
 function extractCodexRolloutSession(raw, agentSlug) {
   const digest = {
@@ -9769,6 +10206,14 @@ function extractCodexRolloutSession(raw, agentSlug) {
     errorCount: 0,
     assistantTurns: 0
   };
+  const signals = emptySessionSignals();
+  const epochMs = [];
+  const models = [];
+  let lastTokenTotals = null;
+  let toolCallsSeen = 0;
+  const assetAcc = new Map;
+  const friction = new FrictionCounters;
+  let failureMarkerSeen = false;
   for (const line of raw.split(`
 `)) {
     if (!line.trim())
@@ -9784,12 +10229,49 @@ function extractCodexRolloutSession(raw, agentSlug) {
       if (!digest.start)
         digest.start = ts;
       digest.end = ts;
+      const ms = Date.parse(ts);
+      if (Number.isFinite(ms))
+        epochMs.push(ms);
     }
     const p = o.payload;
     if (!p || typeof p !== "object")
       continue;
-    if (o.type === "session_meta" && typeof p.cwd === "string") {
-      digest.project = p.cwd;
+    if (o.type === "session_meta") {
+      if (typeof p.cwd === "string")
+        digest.project = p.cwd;
+      signals.provenance = classifyCodexProvenance(p);
+      continue;
+    }
+    if (o.type === "turn_context") {
+      const ap = p.approval_policy;
+      if (typeof ap === "string")
+        signals.approvalPolicy = ap;
+      else if (ap && typeof ap === "object")
+        signals.approvalPolicy = Object.keys(ap)[0] ?? signals.approvalPolicy;
+      const sp = p.sandbox_policy;
+      if (sp && typeof sp === "object" && typeof sp.type === "string")
+        signals.sandboxPolicy = sp.type;
+      if (typeof p.model === "string" && !models.includes(p.model))
+        models.push(p.model);
+      continue;
+    }
+    if (o.type === "event_msg") {
+      if (p.type === "token_count") {
+        const info = p.info;
+        if (info && typeof info === "object" && info.total_token_usage && typeof info.total_token_usage === "object") {
+          lastTokenTotals = info.total_token_usage;
+        }
+      } else if (p.type === "exec_command_end") {
+        failureMarkerSeen = true;
+        friction.result(typeof p.exit_code === "number" && p.exit_code !== 0);
+      } else if (p.type === "mcp_tool_call_end") {
+        const result = p.result;
+        failureMarkerSeen = true;
+        friction.result(Boolean(result && typeof result === "object" && "Err" in result));
+      } else if (p.type === "patch_apply_end") {
+        failureMarkerSeen = true;
+        friction.result(p.success === false);
+      }
       continue;
     }
     if (o.type !== "response_item")
@@ -9815,6 +10297,17 @@ function extractCodexRolloutSession(raw, agentSlug) {
       }
     } else if (pt === "function_call" && typeof p.name === "string") {
       digest.toolCounts[p.name] = (digest.toolCounts[p.name] ?? 0) + 1;
+      friction.call(p.name, typeof p.arguments === "string" ? p.arguments : null);
+      if (p.name === "save_skill" && typeof p.arguments === "string") {
+        try {
+          const args = JSON.parse(p.arguments);
+          if (typeof args.name === "string" && args.name.trim()) {
+            const ms = ts ? Date.parse(ts) : NaN;
+            recordAssetAttempt(assetAcc, args.name.trim(), Number.isFinite(ms) ? ms : null, digest.assistantTurns, toolCallsSeen);
+          }
+        } catch {}
+      }
+      toolCallsSeen++;
     } else if (pt === "tool_search_call") {
       digest.toolCounts["tool_search"] = (digest.toolCounts["tool_search"] ?? 0) + 1;
     }
@@ -9823,6 +10316,21 @@ function extractCodexRolloutSession(raw, agentSlug) {
     return null;
   if (!digest.project)
     digest.project = "codex";
+  applyGapHistogram(signals, epochMs);
+  if (models.length > 0)
+    signals.models = models;
+  if (lastTokenTotals) {
+    signals.tokens = {
+      tokensIn: finiteNum(lastTokenTotals.input_tokens),
+      tokensOut: finiteNum(lastTokenTotals.output_tokens),
+      cacheReadTokens: finiteNum(lastTokenTotals.cached_input_tokens),
+      cacheCreationTokens: null
+    };
+  }
+  signals.toolFailureStreakMax = failureMarkerSeen ? friction.failStreakMax : null;
+  signals.repeatedCallMax = friction.repeatedCallMax;
+  digest.signals = signals;
+  digest.assetMarkers = buildAssetMarkers(assetAcc, epochMs);
   return digest;
 }
 function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
@@ -9871,6 +10379,7 @@ function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
       errorCount: 0,
       assistantTurns: 0
     };
+    const friction = new FrictionCounters;
     for (const b of bubbles) {
       if (b.ts) {
         if (!digest.start)
@@ -9881,6 +10390,7 @@ function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
         digest.toolCounts[b.tool] = (digest.toolCounts[b.tool] ?? 0) + 1;
         if (b.status === "error")
           digest.errorCount++;
+        friction.result(b.status === "error");
       } else if (b.type === 2) {
         digest.assistantTurns++;
       }
@@ -9907,6 +10417,9 @@ function extractCursorSessions(composerRows, bubbleRows, sinceISO) {
       continue;
     if (sinceISO && digest.end && digest.end < sinceISO)
       continue;
+    const signals = emptySessionSignals();
+    signals.toolFailureStreakMax = friction.failStreakMax;
+    digest.signals = signals;
     digests.push(digest);
   }
   return digests;
@@ -9950,7 +10463,7 @@ function formatCombinedDigest(sessions, opts = { days: 7 }) {
   return lines.join(`
 `);
 }
-var MAX_MSG_CHARS = 700, MAX_MSGS_PER_SESSION = 40, SKIP_PREFIXES, CODEX_SKIP_PREFIXES;
+var MAX_MSG_CHARS = 700, MAX_MSGS_PER_SESSION = 40, finiteNum = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0, SKIP_PREFIXES, CODEX_SKIP_PREFIXES;
 var init_session_digest = __esm(() => {
   SKIP_PREFIXES = [
     "<system-reminder",
@@ -10289,7 +10802,7 @@ import { createHash as createHash2 } from "crypto";
 function contentHash(content) {
   return "sha256:" + createHash2("sha256").update(content).digest("hex");
 }
-function stableStringify(value) {
+function stableStringify2(value) {
   return JSON.stringify(sortValue(value));
 }
 function sortValue(value) {
@@ -10306,7 +10819,7 @@ function sortValue(value) {
   return value;
 }
 function configHash(value) {
-  return contentHash(stableStringify(value));
+  return contentHash(stableStringify2(value));
 }
 var init_hash = () => {};
 
@@ -15720,10 +16233,104 @@ var init_conversation_registry = __esm(async () => {
 
 // src/reflect/session-summary.ts
 import { createHash as createHash4 } from "crypto";
+import { execFileSync as execFileSync3 } from "child_process";
 import { readFileSync as readFileSync35 } from "fs";
+import { isAbsolute as isAbsolute4 } from "path";
+function validateAssetMarkers(markers, knownSkills) {
+  if (!markers || markers.length === 0)
+    return null;
+  let known = null;
+  if (knownSkills) {
+    known = new Map;
+    for (const skill of knownSkills) {
+      const name = canonicalSkillName(skill.name);
+      if (name)
+        known.set(name, skill.id);
+    }
+  }
+  return markers.map((m) => {
+    const canonical = canonicalSkillName(m.rawName);
+    const validated = Boolean(known && canonical && known.has(canonical));
+    return {
+      assetKind: m.kind,
+      assetKey: validated ? canonical : null,
+      assetKeyId: validated ? known.get(canonical) ?? null : null,
+      saveAttempts: m.attempts,
+      turnsToAsset: m.turnsBefore,
+      toolCallsToAsset: m.toolCallsBefore,
+      wallSecondsToAsset: m.wallSecondsToAsset,
+      gapCountsToAsset: m.gapCountsToAsset,
+      gapSecondsToAsset: m.gapSecondsToAsset
+    };
+  });
+}
+function clampVendorString(value) {
+  if (value === null)
+    return null;
+  return value.length > VENDOR_STRING_MAX_CHARS ? value.slice(0, VENDOR_STRING_MAX_CHARS) : value;
+}
+function clampVendorList(values) {
+  if (values === null)
+    return null;
+  return values.slice(0, VENDOR_LIST_MAX_ITEMS).map((v) => clampVendorString(v));
+}
+function clampTokensByModel(map) {
+  if (map === null)
+    return null;
+  const entries = Object.entries(map).slice(0, VENDOR_LIST_MAX_ITEMS).map(([model, totals]) => [clampVendorString(model), totals]);
+  return Object.fromEntries(entries);
+}
 function hashSessionKey(key) {
   return createHash4("sha256").update(key).digest("hex").slice(0, 32);
 }
+function normalizeGitRemote(url) {
+  let out = url.trim().toLowerCase();
+  if (!out)
+    return null;
+  const hadScheme = /^[a-z+]+:\/\//.test(out);
+  out = out.replace(/^[a-z+]+:\/\//, "");
+  out = out.replace(/^[^@/]+@/, "");
+  if (hadScheme)
+    out = out.replace(/^([^/:]+):(\d+)(?=\/)/, "$1");
+  out = out.replace(":", "/");
+  out = out.replace(/\/+$/, "");
+  out = out.replace(/\.git$/, "");
+  out = out.replace(/\/+$/, "");
+  return out || null;
+}
+function normalizeProjectName(project) {
+  if (!project)
+    return null;
+  const trimmed = project.trim().replace(/[/\\]+$/, "");
+  if (!trimmed)
+    return null;
+  const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  const base = (idx >= 0 ? trimmed.slice(idx + 1) : trimmed).toLowerCase();
+  if (!base)
+    return null;
+  if (idx < 0 && PROJECT_PLACEHOLDERS.has(base))
+    return null;
+  return base;
+}
+function resolveProjectHash(project) {
+  const normalized = normalizeProjectName(project);
+  return normalized ? hashSessionKey(normalized) : null;
+}
+function resolveRepoHash(projectDir) {
+  if (!projectDir || !isAbsolute4(projectDir))
+    return null;
+  let url;
+  try {
+    url = execFileSync3("git", ["-C", projectDir, "config", "--get", "remote.origin.url"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3000
+    }).toString().trim();
+  } catch {
+    return null;
+  }
+  const normalized = url ? normalizeGitRemote(url) : null;
+  return normalized ? hashSessionKey(normalized) : null;
+}
 function digestForEntry(entry) {
   if (!entry.transcriptPath)
     return null;
@@ -15757,9 +16364,10 @@ function deriveMcpUsage(toolCounts) {
   }
   return { mcpCallCount, mcpServers };
 }
-function buildSessionSummary(key, entry, digest) {
+function buildSessionSummary(key, entry, digest, opts = {}) {
   const toolCallCount = digest ? Object.values(digest.toolCounts).reduce((sum, n) => sum + n, 0) : null;
   const userMessageCount = digest ? digest.userMessages.length + digest.droppedUserMessages : null;
+  const sig = digest?.signals;
   return {
     agentSlug: entry.agentSlug,
     sessionIdHash: hashSessionKey(key),
@@ -15772,7 +16380,32 @@ function buildSessionSummary(key, entry, digest) {
     toolCounts: digest ? digest.toolCounts : null,
     ...deriveMcpUsage(digest ? digest.toolCounts : null),
     errorCount: digest?.errorCount ?? null,
-    skillsUsed: [...new Set((digest?.skillInvocations ?? []).map(canonicalSkillName).filter(Boolean))]
+    skillsUsed: clampVendorList([...new Set((digest?.skillInvocations ?? []).map(canonicalSkillName).filter(Boolean))]) ?? [],
+    provenance: sig?.provenance ?? null,
+    gapCounts: sig?.gapCounts ?? null,
+    gapSeconds: sig?.gapSeconds ?? null,
+    spanMinutes: sig?.spanMinutes ?? null,
+    longestGapSeconds: sig?.longestGapSeconds ?? null,
+    permissionModes: clampVendorList(sig?.permissionModes ?? null),
+    modeEscalations: sig?.modeEscalations ?? null,
+    approvalPolicy: clampVendorString(sig?.approvalPolicy ?? null),
+    sandboxPolicy: clampVendorString(sig?.sandboxPolicy ?? null),
+    subagentCount: sig?.subagentCount ?? null,
+    planModeUsed: sig?.planModeUsed ?? null,
+    slashCommandCount: sig?.slashCommandCount ?? null,
+    modelInitiatedSkillCount: sig?.modelInitiatedSkillCount ?? null,
+    promptLengthBuckets: sig?.promptLengthBuckets ?? null,
+    toolFailureStreakMax: sig?.toolFailureStreakMax ?? null,
+    repeatedCallMax: sig?.repeatedCallMax ?? null,
+    models: clampVendorList(sig?.models ?? null),
+    tokensIn: sig?.tokens?.tokensIn ?? null,
+    tokensOut: sig?.tokens?.tokensOut ?? null,
+    cacheReadTokens: sig?.tokens?.cacheReadTokens ?? null,
+    cacheCreationTokens: sig?.tokens?.cacheCreationTokens ?? null,
+    tokensByModel: clampTokensByModel(sig?.tokensByModel ?? null),
+    assetsCreated: validateAssetMarkers(digest?.assetMarkers, opts.knownSkills ?? null),
+    repoHash: opts.repoHash ?? null,
+    projectHash: resolveProjectHash(entry.project)
   };
 }
 function buildSessionSummaryEvent(summary, nowISO) {
@@ -15793,14 +16426,41 @@ function buildSessionSummaryEvent(summary, nowISO) {
         mcpCallCount: summary.mcpCallCount,
         mcpServers: summary.mcpServers,
         errorCount: summary.errorCount,
-        skillsUsed: summary.skillsUsed
+        skillsUsed: summary.skillsUsed,
+        provenance: summary.provenance,
+        gapCounts: summary.gapCounts,
+        gapSeconds: summary.gapSeconds,
+        spanMinutes: summary.spanMinutes,
+        longestGapSeconds: summary.longestGapSeconds,
+        permissionModes: summary.permissionModes,
+        modeEscalations: summary.modeEscalations,
+        approvalPolicy: summary.approvalPolicy,
+        sandboxPolicy: summary.sandboxPolicy,
+        subagentCount: summary.subagentCount,
+        planModeUsed: summary.planModeUsed,
+        slashCommandCount: summary.slashCommandCount,
+        modelInitiatedSkillCount: summary.modelInitiatedSkillCount,
+        promptLengthBuckets: summary.promptLengthBuckets,
+        toolFailureStreakMax: summary.toolFailureStreakMax,
+        repeatedCallMax: summary.repeatedCallMax,
+        models: summary.models,
+        tokensIn: summary.tokensIn,
+        tokensOut: summary.tokensOut,
+        cacheReadTokens: summary.cacheReadTokens,
+        cacheCreationTokens: summary.cacheCreationTokens,
+        tokensByModel: summary.tokensByModel,
+        assetsCreated: summary.assetsCreated,
+        repoHash: summary.repoHash,
+        projectHash: summary.projectHash
       },
       timestamp: nowISO
     }
   };
 }
+var VENDOR_STRING_MAX_CHARS = 64, VENDOR_LIST_MAX_ITEMS = 12, PROJECT_PLACEHOLDERS;
 var init_session_summary = __esm(() => {
   init_session_digest();
+  PROJECT_PLACEHOLDERS = new Set(["codex", "cowork", "cursor"]);
 });
 
 // src/reflect/telemetry-outbox.ts
@@ -15842,6 +16502,222 @@ var init_telemetry_outbox = __esm(() => {
   init_atomic_json();
 });
 
+// src/reflect/active-time.ts
+function isValidActiveTimeCap(capSeconds) {
+  return VALID_ACTIVE_TIME_CAPS_SECONDS.includes(capSeconds);
+}
+function activeSecondsFromBuckets(gapCounts, gapSeconds, capSeconds) {
+  if (!gapCounts || !gapSeconds)
+    return null;
+  if (!isValidActiveTimeCap(capSeconds))
+    return null;
+  let total = 0;
+  for (const { key, lower } of BUCKET_LOWER_EDGES) {
+    if (lower >= capSeconds) {
+      total += capSeconds * (gapCounts[key] ?? 0);
+    } else {
+      total += gapSeconds[key] ?? 0;
+    }
+  }
+  return total;
+}
+var BUCKET_LOWER_EDGES, VALID_ACTIVE_TIME_CAPS_SECONDS;
+var init_active_time = __esm(() => {
+  BUCKET_LOWER_EDGES = [
+    { key: "lt10s", lower: 0 },
+    { key: "s10to30", lower: 10 },
+    { key: "s30to2m", lower: 30 },
+    { key: "m2to5", lower: 120 },
+    { key: "m5to15", lower: 300 },
+    { key: "gte15m", lower: 900 }
+  ];
+  VALID_ACTIVE_TIME_CAPS_SECONDS = [10, 30, 120, 300, 900];
+});
+
+// src/reflect/pattern-store.ts
+import { createHash as createHash5 } from "crypto";
+import { join as join42 } from "path";
+import { homedir as homedir23 } from "os";
+function addBuckets(a, b) {
+  if (!a)
+    return b ? { ...b } : null;
+  if (!b)
+    return { ...a };
+  return {
+    lt10s: a.lt10s + b.lt10s,
+    s10to30: a.s10to30 + b.s10to30,
+    s30to2m: a.s30to2m + b.s30to2m,
+    m2to5: a.m2to5 + b.m2to5,
+    m5to15: a.m5to15 + b.m5to15,
+    gte15m: a.gte15m + b.gte15m
+  };
+}
+function canonicalizeEntities(entities) {
+  const cleaned = entities.map((e) => e.trim().toLowerCase().replace(/\s+/g, " ")).filter((e) => e.length > 0);
+  return [...new Set(cleaned)].sort().slice(0, MAX_KEY_ENTITIES);
+}
+function patternKeyHash(taskType, entities) {
+  const task = taskType.trim().toLowerCase();
+  const canonical = canonicalizeEntities(entities);
+  if (!task || canonical.length === 0)
+    return null;
+  return createHash5("sha256").update(`${task}|${canonical.join(",")}`).digest("hex").slice(0, 32);
+}
+function median(sorted) {
+  if (sorted.length === 0)
+    return 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function medianOf(values) {
+  return median([...values].sort((a, b) => a - b));
+}
+function modal(values) {
+  const counts = new Map;
+  for (const v of values)
+    counts.set(v, (counts.get(v) ?? 0) + 1);
+  let best = null;
+  let bestCount = 0;
+  for (const [value, count] of counts) {
+    if (count > bestCount) {
+      best = value;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function emptyPatternStore() {
+  return { version: PATTERN_STORE_VERSION, patterns: {} };
+}
+function recordObservation(state, observation) {
+  const key = patternKeyHash(observation.taskType, observation.keyEntities);
+  if (!key)
+    return { state, key: null };
+  const at = Date.parse(observation.at);
+  if (!Number.isFinite(at))
+    return { state, key: null };
+  const activeSeconds = observation.gapCounts && observation.gapSeconds ? activeSecondsFromBuckets(observation.gapCounts, observation.gapSeconds, ACTIVE_MINUTES_CAP_SECONDS) : null;
+  const existing = state.patterns[key];
+  const occurrences = existing ? [...existing.occurrences] : [];
+  const mergeIndex = occurrences.findIndex((o) => Math.abs(Date.parse(o.at) - at) <= SAME_OCCURRENCE_WINDOW_HOURS * 3600 * 1000);
+  if (mergeIndex >= 0) {
+    const prior = occurrences[mergeIndex];
+    const priorAt = Date.parse(prior.at);
+    occurrences[mergeIndex] = {
+      at: priorAt <= at ? prior.at : observation.at,
+      activeSeconds: prior.activeSeconds === null && activeSeconds === null ? null : (prior.activeSeconds ?? 0) + (activeSeconds ?? 0),
+      gapCounts: addBuckets(prior.gapCounts, observation.gapCounts),
+      gapSeconds: addBuckets(prior.gapSeconds, observation.gapSeconds),
+      confidence: Math.min(prior.confidence, observation.confidence),
+      sessionIdHashes: observation.sessionIdHash && !prior.sessionIdHashes.includes(observation.sessionIdHash) ? [...prior.sessionIdHashes, observation.sessionIdHash] : prior.sessionIdHashes,
+      suggestedCapability: prior.suggestedCapability ?? observation.suggestedCapability ?? null,
+      projectHash: prior.projectHash ?? observation.projectHash ?? null
+    };
+  } else {
+    occurrences.push({
+      at: observation.at,
+      activeSeconds,
+      gapCounts: observation.gapCounts ?? null,
+      gapSeconds: observation.gapSeconds ?? null,
+      confidence: observation.confidence,
+      sessionIdHashes: observation.sessionIdHash ? [observation.sessionIdHash] : [],
+      suggestedCapability: observation.suggestedCapability ?? null,
+      projectHash: observation.projectHash ?? null
+    });
+  }
+  occurrences.sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  const newest = Date.parse(occurrences[occurrences.length - 1].at);
+  const kept = occurrences.filter((o) => newest - Date.parse(o.at) <= OCCURRENCE_RETENTION_DAYS * 24 * 3600 * 1000);
+  return {
+    state: {
+      ...state,
+      patterns: {
+        ...state.patterns,
+        [key]: {
+          taskType: observation.taskType.trim().toLowerCase(),
+          keyEntities: canonicalizeEntities(observation.keyEntities),
+          occurrences: kept
+        }
+      }
+    },
+    key
+  };
+}
+function evaluateMaturity(key, record) {
+  const sorted = [...record.occurrences].sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  if (sorted.length < MATURITY_MIN_OCCURRENCES)
+    return null;
+  const newest = Date.parse(sorted[sorted.length - 1].at);
+  const inWindow = sorted.filter((o) => newest - Date.parse(o.at) <= MATURITY_WINDOW_DAYS * 24 * 3600 * 1000);
+  if (inWindow.length < MATURITY_MIN_OCCURRENCES)
+    return null;
+  const gapsDays = [];
+  for (let i = 1;i < inWindow.length; i++) {
+    gapsDays.push((Date.parse(inWindow[i].at) - Date.parse(inWindow[i - 1].at)) / (24 * 3600 * 1000));
+  }
+  const medianGap = medianOf(gapsDays);
+  if (medianGap < MATURITY_MIN_PERIODICITY_DAYS)
+    return null;
+  const mad = medianOf(gapsDays.map((g) => Math.abs(g - medianGap)));
+  if (mad > MATURITY_MAX_MAD_RATIO * medianGap)
+    return null;
+  const activeSecondsValues = inWindow.map((o) => o.activeSeconds).filter((s) => typeof s === "number");
+  let activeGapCounts = null;
+  let activeGapSeconds = null;
+  for (const occurrence of inWindow) {
+    activeGapCounts = addBuckets(activeGapCounts, occurrence.gapCounts);
+    activeGapSeconds = addBuckets(activeGapSeconds, occurrence.gapSeconds);
+  }
+  const projectHashes = inWindow.map((o) => o.projectHash).filter((p) => typeof p === "string" && p.length > 0);
+  const capabilities = inWindow.map((o) => o.suggestedCapability).filter((c) => typeof c === "string" && c.length > 0);
+  return {
+    patternKeyHash: key,
+    taskType: record.taskType,
+    occurrences: inWindow.length,
+    periodicityDays: Math.round(medianGap * 10) / 10,
+    medianActiveMinutes: activeSecondsValues.length > 0 ? Math.round(medianOf(activeSecondsValues) / 60 * 10) / 10 : null,
+    activeMinutesCapSeconds: ACTIVE_MINUTES_CAP_SECONDS,
+    activeGapCounts,
+    activeGapSeconds,
+    suggestedCapability: modal(capabilities),
+    firstSeenAt: inWindow[0].at,
+    lastSeenAt: inWindow[inWindow.length - 1].at,
+    confidence: Math.min(...inWindow.map((o) => o.confidence)),
+    projectHash: modal(projectHashes),
+    distinctProjectHashes: new Set(projectHashes).size
+  };
+}
+function buildPatternEvent(payload, nowISO) {
+  return {
+    dedupeKey: `pattern:${payload.patternKeyHash}`,
+    event: {
+      eventType: "local_agent.repeated_pattern",
+      metadata: { ...payload },
+      timestamp: nowISO
+    }
+  };
+}
+function storePath3() {
+  return join42(homedir23(), ".runwork", "pattern-store.json");
+}
+function loadPatternStore() {
+  const parsed = readJsonOrNull(storePath3());
+  if (!parsed || typeof parsed !== "object" || !parsed.patterns || typeof parsed.patterns !== "object") {
+    return emptyPatternStore();
+  }
+  if (parsed.version !== PATTERN_STORE_VERSION)
+    return emptyPatternStore();
+  return parsed;
+}
+function savePatternStore(state) {
+  writeJsonAtomic(storePath3(), state);
+}
+var SAME_OCCURRENCE_WINDOW_HOURS = 4, MATURITY_MIN_OCCURRENCES = 3, MATURITY_WINDOW_DAYS = 45, MATURITY_MAX_MAD_RATIO = 0.5, MATURITY_MIN_PERIODICITY_DAYS = 1, OCCURRENCE_RETENTION_DAYS = 180, MAX_KEY_ENTITIES = 4, ACTIVE_MINUTES_CAP_SECONDS = 300, PATTERN_STORE_VERSION = 1;
+var init_pattern_store = __esm(() => {
+  init_atomic_json();
+  init_active_time();
+});
+
 // src/reflect/triage.ts
 var exports_triage = {};
 __export(exports_triage, {
@@ -15852,7 +16728,8 @@ __export(exports_triage, {
   packTriageBatches: () => packTriageBatches,
   buildTriagePrompt: () => buildTriagePrompt,
   TRIAGE_ITEM_CHAR_CAP: () => TRIAGE_ITEM_CHAR_CAP,
-  TRIAGE_BATCH_CHAR_BUDGET: () => TRIAGE_BATCH_CHAR_BUDGET
+  TRIAGE_BATCH_CHAR_BUDGET: () => TRIAGE_BATCH_CHAR_BUDGET,
+  TASK_TYPES: () => TASK_TYPES
 });
 function renderTriageItem(id, candidate) {
   const d = candidate.digest;
@@ -15901,12 +16778,17 @@ You are the cheap triage tier of Runwork's reflection engine. At the end of this
 
 Mark a conversation NOT worthy when it is trivial or one-shot, is routine work with no repeated pattern, or would only re-derive something in the already-suggested list. Most conversations are not worthy; be strict. Do not analyze content deeply — skim and judge.
 
+For EACH conversation also label the work itself, which is used to notice the same chore recurring across conversations:
+
+- "taskType": exactly one of ${TASK_TYPES.join(" | ")}.
+- "keyEntities": 1 to 4 short CANONICAL noun phrases naming the OBJECT of the work ("invoice reformatting", "weekly sales report", "hubspot contact cleanup"). Canonical means: singular, lowercase, generic. NO dates, file names, person names, company names, counts, or version numbers. Two conversations doing the same chore in different words MUST produce the same phrases, so prefer the plainest wording of the underlying task over the user's phrasing.
+
 Reply with ONLY a single fenced \`json\` block:
 
 \`\`\`json
 {
   "verdicts": [
-    { "id": "<the conversation id shown in its header>", "worthy": true|false, "confidence": <0..1> }
+    { "id": "<the conversation id shown in its header>", "worthy": true|false, "confidence": <0..1>, "taskType": "<one of the values above>", "keyEntities": ["<canonical phrase>"] }
   ]
 }
 \`\`\`
@@ -15936,9 +16818,13 @@ function parseTriageVerdicts(text2) {
       const v = raw;
       if (typeof v.id !== "string" || typeof v.worthy !== "boolean")
         continue;
+      const taskType = typeof v.taskType === "string" && TASK_TYPES.includes(v.taskType.trim().toLowerCase()) ? v.taskType.trim().toLowerCase() : undefined;
+      const keyEntities = Array.isArray(v.keyEntities) ? v.keyEntities.filter((e) => typeof e === "string" && e.trim().length > 0).map((e) => e.trim()) : [];
       out.set(v.id, {
         worthy: v.worthy,
-        confidence: typeof v.confidence === "number" ? Math.max(0, Math.min(1, v.confidence)) : 0.5
+        confidence: typeof v.confidence === "number" ? Math.max(0, Math.min(1, v.confidence)) : 0.5,
+        ...taskType ? { taskType } : {},
+        ...keyEntities.length > 0 ? { keyEntities } : {}
       });
     }
     return out.size > 0 ? out : null;
@@ -16009,7 +16895,7 @@ async function runTriagePass(candidates, opts) {
   }
   return { verdicts, summary };
 }
-var TRIAGE_ITEM_CHAR_CAP = 12000, TRIAGE_BATCH_CHAR_BUDGET = 150000, TRIAGE_TIMEOUT_MS;
+var TRIAGE_ITEM_CHAR_CAP = 12000, TRIAGE_BATCH_CHAR_BUDGET = 150000, TRIAGE_TIMEOUT_MS, TASK_TYPES;
 var init_triage = __esm(async () => {
   init_which();
   init_session_listing();
@@ -16018,6 +16904,7 @@ var init_triage = __esm(async () => {
     init_conversation_analysis()
   ]);
   TRIAGE_TIMEOUT_MS = 2 * 60 * 1000;
+  TASK_TYPES = ["build", "automate", "analyze", "write", "research", "admin", "debug"];
 });
 
 // src/reflect/conversation-analysis.ts
@@ -16182,6 +17069,48 @@ async function analyzeConversations(opts = {}) {
     releaseRunLock();
   }
 }
+function recordPatternObservations(verdicts, state, progress) {
+  try {
+    let store = loadPatternStore();
+    const touchedKeys = new Set;
+    for (const [key, verdict] of verdicts) {
+      const entry = state.entries[key];
+      if (!entry || !verdict.taskType || !verdict.keyEntities?.length)
+        continue;
+      const stats = entry.stats;
+      const result = recordObservation(store, {
+        taskType: verdict.taskType,
+        keyEntities: verdict.keyEntities,
+        at: entry.lastActivityAt,
+        confidence: verdict.confidence,
+        sessionIdHash: stats?.sessionIdHash,
+        gapCounts: stats?.gapCounts ?? null,
+        gapSeconds: stats?.gapSeconds ?? null,
+        projectHash: stats?.projectHash ?? null
+      });
+      store = result.state;
+      if (result.key)
+        touchedKeys.add(result.key);
+    }
+    if (touchedKeys.size === 0)
+      return;
+    savePatternStore(store);
+    const nowISO = new Date().toISOString();
+    const events = [];
+    for (const key of touchedKeys) {
+      const record = store.patterns[key];
+      if (!record)
+        continue;
+      const payload = evaluateMaturity(key, record);
+      if (payload)
+        events.push(buildPatternEvent(payload, nowISO));
+    }
+    if (events.length > 0) {
+      appendToTelemetryOutbox(events);
+      progress(`${events.length} recurring chore pattern(s) reached the recurrence threshold.`);
+    }
+  } catch {}
+}
 async function analyzeConversationsLocked(opts, outcome, gates) {
   const { cadence, explicitSession, manual } = gates;
   if (!cadence.enabled && !manual && !explicitSession) {
@@ -16318,9 +17247,11 @@ async function analyzeConversationsLocked(opts, outcome, gates) {
         for (const [key, verdict] of pass.verdicts) {
           const entry = state.entries[key];
           if (entry) {
-            state = { entries: { ...state.entries, [key]: { ...entry, triage: { ...verdict, at: entry.lastActivityAt } } } };
+            const { keyEntities: _entities, ...cacheable } = verdict;
+            state = { entries: { ...state.entries, [key]: { ...entry, triage: { ...cacheable, at: entry.lastActivityAt } } } };
           }
         }
+        recordPatternObservations(pass.verdicts, state, progress);
       }
     }
     const ranked = [];
@@ -16540,6 +17471,7 @@ var init_conversation_analysis = __esm(async () => {
   init_session_listing();
   init_insight_store();
   init_telemetry_outbox();
+  init_pattern_store();
   init_run_log();
   init_insight_store();
   await __promiseAll([
@@ -19036,14 +19968,18 @@ init_session_summary();
 init_telemetry_outbox();
 init_insight_store();
 init_atomic_json();
+init_store();
+init_client();
+init_resolve();
+init_workspace_state();
 init_colors();
 await __promiseAll([
   init_conversation_registry(),
   init_conversation_analysis()
 ]);
 import { Command as Command15 } from "commander";
-import { join as join42 } from "path";
-import { homedir as homedir23 } from "os";
+import { join as join43 } from "path";
+import { homedir as homedir24 } from "os";
 var DEFAULT_LOOKBACK_DAYS = 30;
 function sinceFromDays(days) {
   if (days <= 0)
@@ -19056,6 +19992,46 @@ function parseDays(raw) {
     return DEFAULT_LOOKBACK_DAYS;
   return Math.floor(n);
 }
+function bareRegistrySkillId(skill) {
+  if (skill.type !== "external" || typeof skill.id !== "string")
+    return null;
+  return skill.id.startsWith("ext-") ? skill.id.slice("ext-".length) || null : null;
+}
+async function fetchKnownSkills() {
+  const creds = getCredentials();
+  if (!creds)
+    return null;
+  let workspaceId;
+  const client = new ApiClient(creds);
+  try {
+    workspaceId = (await resolveWorkspace2(client, {})).workspaceId;
+  } catch {
+    workspaceId = creds.defaultWorkspaceId;
+  }
+  if (!workspaceId)
+    return null;
+  try {
+    const skills = await client.listWorkspaceSkills(workspaceId);
+    const known = [];
+    const seen = new Set;
+    for (const sk of skills) {
+      if (sk.type === "app")
+        continue;
+      const name = canonicalSkillName(sk.name);
+      if (!name || seen.has(name))
+        continue;
+      seen.add(name);
+      known.push({ name, id: bareRegistrySkillId(sk) });
+    }
+    updateWorkspaceRecord(workspaceId, { knownSkills: known });
+    return known;
+  } catch {
+    const record = loadWorkspaceRecord(workspaceId);
+    if (record.knownSkills)
+      return record.knownSkills;
+    return record.skillNames ? record.skillNames.map((name) => ({ name, id: null })) : null;
+  }
+}
 function projectLabel(project) {
   const trimmed = project.replace(/[/\\]+$/, "");
   const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
@@ -19112,11 +20088,21 @@ conversationsCommand.command("scan").description("Detect finished conversations
   const nowISO = new Date().toISOString();
   const summaryEvents = [];
   const newlyPending = new Set(scan.newlyPendingKeys);
+  const knownSkills = newlyPending.size > 0 ? await fetchKnownSkills() : null;
+  const repoHashByProject = new Map;
+  const repoHashFor = (project) => {
+    if (!repoHashByProject.has(project))
+      repoHashByProject.set(project, resolveRepoHash(project));
+    return repoHashByProject.get(project) ?? null;
+  };
   let statsWritten = 0;
   for (const [key, entry] of Object.entries(scan.state.entries)) {
     if (!newlyPending.has(key) && entry.stats)
       continue;
-    const summary = buildSessionSummary(key, entry, digestForEntry(entry));
+    const summary = buildSessionSummary(key, entry, digestForEntry(entry), {
+      knownSkills,
+      repoHash: repoHashFor(entry.project)
+    });
     scan.state.entries[key] = { ...entry, stats: summary };
     statsWritten++;
     if (newlyPending.has(key))
@@ -19155,7 +20141,7 @@ conversationsCommand.command("scan").description("Detect finished conversations
     idleMinutes,
     conversations: [...listed, ...rescued].sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt))
   };
-  writeJsonAtomic(join42(homedir23(), ".runwork", "conversations.json"), snapshot);
+  writeJsonAtomic(join43(homedir24(), ".runwork", "conversations.json"), snapshot);
   if (json) {
     jsonOut({ queued: scan.queued, reopened: scan.reopened, pruned: scan.pruned, pending, finished: finished.length });
     return;
@@ -19185,8 +20171,8 @@ init_client();
 init_resolve();
 import { Command as Command16 } from "commander";
 import { readFileSync as readFileSync37, existsSync as existsSync48 } from "fs";
-import { join as join43 } from "path";
-import { homedir as homedir24 } from "os";
+import { join as join44 } from "path";
+import { homedir as homedir25 } from "os";
 
 // ../../shared/agent-instructions/runwork-instructions.ts
 function formatList(items, max = 8) {
@@ -19327,17 +20313,22 @@ function toRunworkInventory(ctx) {
     mcpServerCount: ctx.mcpServerCount
   };
 }
-function buildAppSkillDescription(appName, registries) {
+function buildAppSkillDescription(skill, registries) {
+  const appName = skill.name;
+  const fallback = `${appName} - Runwork workspace application`;
   if (!registries)
-    return `${appName} - Runwork workspace application`;
+    return fallback;
+  if (!skill.appId)
+    return fallback;
+  const appId = skill.appId;
   const parts = [];
-  const appEntities = registries.entities.filter((e) => e.appName === appName);
-  const appSchedules = registries.schedules.filter((s) => s.appName === appName);
-  const appWorkflows = registries.workflows.filter((w) => w.appName === appName);
-  const appAgents = registries.agents.filter((a) => a.appName === appName);
-  const appEndpoints = registries.endpoints.filter((e) => e.appName === appName);
-  const appFileStorages = registries.fileStorages.filter((f) => f.appName === appName);
-  const appComponents = registries.components.filter((c) => c.appName === appName);
+  const appEntities = registries.entities.filter((e) => e.appId === appId);
+  const appSchedules = registries.schedules.filter((s) => s.appId === appId);
+  const appWorkflows = registries.workflows.filter((w) => w.appId === appId);
+  const appAgents = registries.agents.filter((a) => a.appId === appId);
+  const appEndpoints = registries.endpoints.filter((e) => e.appId === appId);
+  const appFileStorages = registries.fileStorages.filter((f) => f.appId === appId);
+  const appComponents = registries.components.filter((c) => c.appId === appId);
   if (appEntities.length > 0)
     parts.push(`entities (${appEntities.map((e) => e.entityName).join(", ")})`);
   if (appFileStorages.length > 0)
@@ -19353,7 +20344,7 @@ function buildAppSkillDescription(appName, registries) {
   if (appComponents.length > 0)
     parts.push(`components (${appComponents.map((c) => c.componentName).join(", ")})`);
   if (parts.length === 0)
-    return `${appName} - Runwork workspace application`;
+    return fallback;
   return `${appName} - Runwork workspace app with ${parts.join(", ")}. Use this skill when you need data or capabilities from this app.`;
 }
 function generateIntroSkill(ctx) {
@@ -19661,8 +20652,8 @@ async function buildInstructionContext(client, workspace) {
 // src/commands/instructions.ts
 function readSetupExtras(workspaceId) {
   for (const path2 of [
-    join43(process.cwd(), ".runwork", "setup.json"),
-    join43(homedir24(), ".runwork", "setup.json")
+    join44(process.cwd(), ".runwork", "setup.json"),
+    join44(homedir25(), ".runwork", "setup.json")
   ]) {
     if (!existsSync48(path2))
       continue;
@@ -19877,7 +20868,12 @@ var listCommand3 = new Command17("list").description("List entities registered i
   try {
     let entities = await client.listEntities(workspaceId);
     if (opts.app) {
-      entities = entities.filter((e) => e.appId === opts.app || e.appName === opts.app);
+      const filtered = filterRowsByApp(entities, opts.app, await client.listApps(workspaceId));
+      if (filtered === null) {
+        console.error(`App "${opts.app}" not found in this workspace.`);
+        process.exit(1);
+      }
+      entities = filtered;
     }
     if (opts.preview) {
       entities = entities.filter((e) => e.deploymentMode === "preview");
@@ -20226,7 +21222,12 @@ var listCommand4 = new Command18("list").description("List workflows in a worksp
   try {
     let workflows = await client.listWorkflows(workspaceId);
     if (opts.app) {
-      workflows = workflows.filter((w) => w.appId === opts.app || w.appName === opts.app);
+      const filtered = filterRowsByApp(workflows, opts.app, await client.listApps(workspaceId));
+      if (filtered === null) {
+        console.error(`App "${opts.app}" not found in this workspace.`);
+        process.exit(1);
+      }
+      workflows = filtered;
     }
     if (useJson) {
       jsonOut({ workflows });
@@ -20585,7 +21586,10 @@ function truncate3(text2, max) {
     return first;
   return first.slice(0, max - 3) + "...";
 }
-var listCommand6 = new Command20("list").description("List workspace public endpoints").option("--workspace <name-or-id>", "Workspace name or ID").option("--app <name>", "Filter by app name or ID").action(async (opts, command) => {
+function filterEndpointsByApp(endpoints, appRef, apps) {
+  return filterRowsByApp(endpoints, appRef, apps);
+}
+var listCommand6 = new Command20("list").description("List workspace public endpoints").option("--workspace <name-or-id>", "Workspace name or ID").option("--app <slug>", "Filter by app slug, name, or ID").action(async (opts, command) => {
   const useJson = shouldOutputJson(command.optsWithGlobals().json);
   const credentials = requireAuth();
   const client = new ApiClient(credentials);
@@ -20593,7 +21597,12 @@ var listCommand6 = new Command20("list").description("List workspace public endp
   try {
     let endpoints = await client.listEndpoints(workspaceId);
     if (opts.app) {
-      endpoints = endpoints.filter((e) => e.appId === opts.app || e.appName === opts.app);
+      const filtered = filterEndpointsByApp(endpoints, opts.app, await client.listApps(workspaceId));
+      if (filtered === null) {
+        console.error(`App "${opts.app}" not found in this workspace.`);
+        process.exit(1);
+      }
+      endpoints = filtered;
     }
     if (useJson) {
       jsonOut({ endpoints });
@@ -20623,7 +21632,11 @@ Workspace: ${workspaceName || workspaceId}
     process.exit(1);
   }
 });
-var callCommand2 = new Command20("call").description("Call a workspace endpoint directly").argument("<method>", "HTTP method (GET, POST, PUT, DELETE, etc.)").argument("<path>", "Endpoint path (e.g. /my-endpoint)").option("--workspace <name-or-id>", "Workspace name or ID").option("--app <name>", "App name or ID (narrows endpoint lookup)").option("--body <json>", "Request body as JSON string").option("--header <header>", 'Request header (format: "Key: Value", repeatable)', (val, prev) => [...prev, val], []).option("--query <string>", 'Query string to append to the URL (e.g. "foo=bar&baz=1")').option("--api-key <key>", "API key for Authorization: Bearer header").action(async (method, path4, opts, command) => {
+function methodsForPath(endpoints, path4) {
+  const methods = endpoints.filter((e) => e.endpointPath === path4).map((e) => e.method.toUpperCase());
+  return [...new Set(methods)].sort();
+}
+var callCommand2 = new Command20("call").description("Call a workspace endpoint directly").argument("<method>", "HTTP method (GET, POST, PUT, DELETE, etc.)").argument("<path>", "Endpoint path (e.g. /my-endpoint)").option("--workspace <name-or-id>", "Workspace name or ID").option("--app <slug>", "App slug, name, or ID (narrows endpoint lookup)").option("--body <json>", "Request body as JSON string").option("--header <header>", 'Request header (format: "Key: Value", repeatable)', (val, prev) => [...prev, val], []).option("--query <string>", 'Query string to append to the URL (e.g. "foo=bar&baz=1")').option("--api-key <key>", "API key for Authorization: Bearer header").action(async (method, path4, opts, command) => {
   const useJson = shouldOutputJson(command.optsWithGlobals().json);
   const credentials = requireAuth();
   const client = new ApiClient(credentials);
@@ -20631,13 +21644,23 @@ var callCommand2 = new Command20("call").description("Call a workspace endpoint
   try {
     let endpoints = await client.listEndpoints(workspaceId);
     if (opts.app) {
-      endpoints = endpoints.filter((e) => e.appId === opts.app || e.appName === opts.app);
+      const filtered = filterEndpointsByApp(endpoints, opts.app, await client.listApps(workspaceId));
+      if (filtered === null) {
+        console.error(`App "${opts.app}" not found in this workspace.`);
+        process.exit(1);
+      }
+      endpoints = filtered;
     }
     const targetMethod = method.toUpperCase();
     const endpoint = endpoints.find((e) => e.method.toUpperCase() === targetMethod && e.endpointPath === path4);
     if (!endpoint) {
       console.error(`Endpoint not found: ${targetMethod} ${path4}`);
-      if (endpoints.length > 0) {
+      const otherMethods = methodsForPath(endpoints, path4);
+      if (otherMethods.length > 0) {
+        console.error(`
+${path4} is registered, but not for ${targetMethod}. Try: ${otherMethods.join(", ")}`);
+        console.error(`  runwork endpoints call ${otherMethods[0]} ${path4}`);
+      } else if (endpoints.length > 0) {
         console.error(`
 Available endpoints:`);
         for (const e of endpoints) {
@@ -20907,7 +21930,12 @@ var listCommand8 = new Command22("list").description("List components registered
   try {
     let components = await client.listComponents(workspaceId);
     if (opts.app) {
-      components = components.filter((c) => c.appId === opts.app || c.appName === opts.app);
+      const filtered = filterRowsByApp(components, opts.app, await client.listApps(workspaceId));
+      if (filtered === null) {
+        console.error(`App "${opts.app}" not found in this workspace.`);
+        process.exit(1);
+      }
+      components = filtered;
     }
     if (useJson) {
       jsonOut({ components });
@@ -21040,7 +22068,12 @@ var listCommand10 = new Command24("list").description("List agents in workspace"
   try {
     let agents = await client.listAgents(workspaceId);
     if (opts.app) {
-      agents = agents.filter((a) => a.appId === opts.app || a.appName === opts.app);
+      const filtered = filterRowsByApp(agents, opts.app, await client.listApps(workspaceId));
+      if (filtered === null) {
+        console.error(`App "${opts.app}" not found in this workspace.`);
+        process.exit(1);
+      }
+      agents = filtered;
     }
     if (useJson) {
       jsonOut({ agents });
@@ -21359,8 +22392,8 @@ init_resolve();
 init_prompt();
 await init_detect();
 import { Command as Command27 } from "commander";
-import { join as join47 } from "path";
-import { homedir as homedir26 } from "os";
+import { join as join48 } from "path";
+import { homedir as homedir27 } from "os";
 
 // src/commands/sync.ts
 init_store();
@@ -21372,8 +22405,8 @@ await __promiseAll([
 ]);
 import { Command as Command26 } from "commander";
 import { readFileSync as readFileSync40, existsSync as existsSync51 } from "fs";
-import { join as join46 } from "path";
-import { homedir as homedir25 } from "os";
+import { join as join47 } from "path";
+import { homedir as homedir26 } from "os";
 
 // src/commands/mcp-entries.ts
 init_types();
@@ -22272,13 +23305,13 @@ function readLocalSkills(state) {
     if (!baseDir)
       continue;
     for (const skillName of state.skills) {
-      const skillMdPath = join46(baseDir, skillName, "SKILL.md");
+      const skillMdPath = join47(baseDir, skillName, "SKILL.md");
       if (existsSync51(skillMdPath)) {
         results.push({ name: skillName, content: readFileSync40(skillMdPath, "utf-8") });
         continue;
       }
       const filename = skillName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const flatPath = join46(baseDir, `${filename}.md`);
+      const flatPath = join47(baseDir, `${filename}.md`);
       if (existsSync51(flatPath)) {
         results.push({ name: skillName, content: readFileSync40(flatPath, "utf-8") });
       }
@@ -22574,7 +23607,7 @@ This account is not a member of "${state.workspaceName || state.workspaceId}".`)
             name: s.name,
             filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
             content: s.content,
-            description: s.source === "app" ? buildAppSkillDescription(s.name, registries) || `${s.name} - Runwork workspace application` : `${s.name} - Runwork workspace skill`
+            description: s.source === "app" ? buildAppSkillDescription(s, registries) || `${s.name} - Runwork workspace application` : `${s.name} - Runwork workspace skill`
           }));
           const allSkillFiles = [...builtInSkills, ...workspaceSkillFiles];
           const written = await adapter2.writeSkills(allSkillFiles, scope);
@@ -22760,7 +23793,7 @@ This account is not a member of "${state.workspaceName || state.workspaceId}".`)
   }
   for (const adapter2 of adapters) {
     if (adapter2 instanceof CodexAdapter) {
-      const runworkDir = join46(homedir25(), ".runwork");
+      const runworkDir = join47(homedir26(), ".runwork");
       const result = adapter2.registerDesktopWorkspace(runworkDir, "Runwork");
       if (result === "written") {
         vlog(`  [${adapter2.name}] Registered workspace in Codex desktop app`);
@@ -22902,8 +23935,8 @@ var syncCommand = new Command26("sync").description("Sync skills bidirectionally
     verbose: !!opts.verbose,
     redetect: !!opts.redetect
   };
-  const projectStatePath = join46(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join46(homedir25(), ".runwork", "setup.json");
+  const projectStatePath = join47(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join47(homedir26(), ".runwork", "setup.json");
   const projectState = loadSetupState(projectStatePath);
   const userState = loadSetupState(userStatePath);
   if (!projectState && !userState) {
@@ -22972,7 +24005,7 @@ function toSkillFilename(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
 }
 function loadSetupStateForScope(scope) {
-  const path4 = scope === "project" ? join47(process.cwd(), ".runwork", "setup.json") : join47(homedir26(), ".runwork", "setup.json");
+  const path4 = scope === "project" ? join48(process.cwd(), ".runwork", "setup.json") : join48(homedir27(), ".runwork", "setup.json");
   return readJsonOrNull(path4);
 }
 async function parkAndTeardownWorkspace(previous, scopes) {
@@ -23141,8 +24174,8 @@ Re-run without --dry-run to sync workspace data.`);
   }
   persistDefaultWorkspace(workspaceId, workspaceName);
   for (const s of scopes) {
-    const dir = s === "project" ? ".runwork" : join47(homedir26(), ".runwork");
-    writeJsonAtomic(join47(dir, "setup.json"), state);
+    const dir = s === "project" ? ".runwork" : join48(homedir27(), ".runwork");
+    writeJsonAtomic(join48(dir, "setup.json"), state);
   }
   if (restored)
     clearParkedState(workspaceId);
@@ -23150,7 +24183,7 @@ Re-run without --dry-run to sync workspace data.`);
 Syncing workspace data...
 `);
   for (const s of scopes) {
-    const statePath2 = s === "project" ? join47(process.cwd(), ".runwork", "setup.json") : join47(homedir26(), ".runwork", "setup.json");
+    const statePath2 = s === "project" ? join48(process.cwd(), ".runwork", "setup.json") : join48(homedir27(), ".runwork", "setup.json");
     await syncFromState(state, statePath2, credentials, {
       dryRun: false,
       pullOnly: true,
@@ -23171,11 +24204,11 @@ import { Command as Command28 } from "commander";
 
 // src/utils/setup-state.ts
 import { existsSync as existsSync52, readFileSync as readFileSync41 } from "fs";
-import { join as join48 } from "path";
-import { homedir as homedir27 } from "os";
+import { join as join49 } from "path";
+import { homedir as homedir28 } from "os";
 function loadSetupState2() {
-  const projectPath = join48(process.cwd(), ".runwork", "setup.json");
-  const userPath = join48(homedir27(), ".runwork", "setup.json");
+  const projectPath = join49(process.cwd(), ".runwork", "setup.json");
+  const userPath = join49(homedir28(), ".runwork", "setup.json");
   for (const p of [projectPath, userPath]) {
     if (existsSync52(p)) {
       try {
@@ -23239,8 +24272,8 @@ init_types();
 await init_detect();
 import { Command as Command29 } from "commander";
 import { existsSync as existsSync53, readFileSync as readFileSync42 } from "fs";
-import { resolve as resolve3, join as join49 } from "path";
-import { homedir as homedir28 } from "os";
+import { resolve as resolve3, join as join50 } from "path";
+import { homedir as homedir29 } from "os";
 function loadSetupState3(filePath) {
   if (!existsSync53(filePath))
     return null;
@@ -23261,8 +24294,8 @@ var buildPluginCommand = new Command29("build-plugin").description("Build an ins
     process.exit(1);
   }
   const credentials = requireAuth();
-  const projectStatePath = join49(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join49(homedir28(), ".runwork", "setup.json");
+  const projectStatePath = join50(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join50(homedir29(), ".runwork", "setup.json");
   const state = loadSetupState3(projectStatePath) ?? loadSetupState3(userStatePath);
   if (!state) {
     console.error("No setup state found. Run `runwork setup` first.");
@@ -23337,7 +24370,7 @@ var buildPluginCommand = new Command29("build-plugin").description("Build an ins
       name: s.name,
       filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
       content: s.content,
-      description: s.source === "app" ? buildAppSkillDescription(s.name, registries) || `${s.name} - Runwork workspace application` : `${s.name} - Runwork workspace skill`
+      description: s.source === "app" ? buildAppSkillDescription(s, registries) || `${s.name} - Runwork workspace application` : `${s.name} - Runwork workspace skill`
     }))
   ];
   const teamInstructions = onboardingConfig?.config?.teamInstructions;
@@ -23355,8 +24388,8 @@ init_prompt();
 await init_detect();
 import { Command as Command30 } from "commander";
 import { existsSync as existsSync54, readFileSync as readFileSync43, rmSync as rmSync13, unlinkSync as unlinkSync8 } from "fs";
-import { join as join50 } from "path";
-import { homedir as homedir29 } from "os";
+import { join as join51 } from "path";
+import { homedir as homedir30 } from "os";
 function loadSetupState4(filePath) {
   if (!existsSync54(filePath))
     return null;
@@ -23367,8 +24400,8 @@ function loadSetupState4(filePath) {
   }
 }
 var uninstallCommand = new Command30("uninstall").description("Remove all Runwork configuration from local agents (MCP servers, skills, instructions)").option("-y, --yes", "Skip confirmation prompt").option("--keep-auth", "Keep authentication credentials (only remove agent configs)").action(async (opts) => {
-  const projectStatePath = join50(process.cwd(), ".runwork", "setup.json");
-  const userStatePath = join50(homedir29(), ".runwork", "setup.json");
+  const projectStatePath = join51(process.cwd(), ".runwork", "setup.json");
+  const userStatePath = join51(homedir30(), ".runwork", "setup.json");
   const projectState = loadSetupState4(projectStatePath);
   const userState = loadSetupState4(userStatePath);
   if (!projectState && !userState) {
@@ -23448,9 +24481,9 @@ This will remove all Runwork configuration from your local agents:
         }
       }
     }
-    const stateDir = label === "project" ? join50(process.cwd(), ".runwork") : join50(homedir29(), ".runwork");
+    const stateDir = label === "project" ? join51(process.cwd(), ".runwork") : join51(homedir30(), ".runwork");
     if (opts.keepAuth && label === "user") {
-      const setupFile = join50(stateDir, "setup.json");
+      const setupFile = join51(stateDir, "setup.json");
       if (existsSync54(setupFile)) {
         try {
           unlinkSync8(setupFile);
@@ -23701,8 +24734,8 @@ init_credentials();
 await init_detect();
 import { parse as parse2 } from "smol-toml";
 import { existsSync as existsSync55, readFileSync as readFileSync45 } from "fs";
-import { join as join51, sep as sep4 } from "path";
-import { homedir as homedir30, platform as osPlatform2, arch as osArch } from "os";
+import { join as join52, sep as sep4 } from "path";
+import { homedir as homedir31, platform as osPlatform2, arch as osArch } from "os";
 var BASE_URL2 = process.env.RUNWORK_DOWNLOAD_BASE_URL || "https://runwork.ai";
 var LATEST_JSON_URL2 = `${BASE_URL2}/cli/latest.json`;
 function detectPlatform() {
@@ -23730,7 +24763,7 @@ function buildContext() {
   const credentials = getCredentials();
   const client = credentials ? new ApiClient(credentials) : null;
   let config = null;
-  const configPath = join51(process.cwd(), ".runwork.json");
+  const configPath = join52(process.cwd(), ".runwork.json");
   if (existsSync55(configPath)) {
     try {
       config = JSON.parse(readFileSync45(configPath, "utf-8"));
@@ -23834,9 +24867,9 @@ async function checkCliArtifactReachable() {
 }
 async function checkCliInstallLocation() {
   const isWindows2 = osPlatform2() === "win32";
-  const home = homedir30();
-  const canonicalDir = join51(home, ".runwork", "bin");
-  const canonicalBinary = isWindows2 ? join51(canonicalDir, "runwork.exe") : join51(canonicalDir, "runwork");
+  const home = homedir31();
+  const canonicalDir = join52(home, ".runwork", "bin");
+  const canonicalBinary = isWindows2 ? join52(canonicalDir, "runwork.exe") : join52(canonicalDir, "runwork");
   const candidates = [process.execPath, process.argv[1] || ""].filter(Boolean);
   const runsFromCanonical = candidates.some((p) => normalizePath(p) === normalizePath(canonicalBinary));
   if (runsFromCanonical) {
@@ -23968,7 +25001,7 @@ async function checkGitCredentialHelper(ctx) {
   };
 }
 async function checkProjectConfig(ctx) {
-  const configPath = join51(ctx.cwd, ".runwork.json");
+  const configPath = join52(ctx.cwd, ".runwork.json");
   if (!existsSync55(configPath)) {
     if (!ctx.credentials) {
       return { name: "project-config", status: "skip", message: "no project (not logged in)" };
@@ -24031,7 +25064,7 @@ async function checkGitRemote(ctx) {
   if (!ctx.config) {
     return { name: "git-remote", status: "skip", message: "skipped (no project)" };
   }
-  if (!existsSync55(join51(ctx.cwd, ".git"))) {
+  if (!existsSync55(join52(ctx.cwd, ".git"))) {
     return {
       name: "git-remote",
       status: "fail",
@@ -24085,8 +25118,8 @@ async function checkDeployFreshness(ctx) {
   return { name: "deploy-freshness", status: "skip", message: "local HEAD unknown" };
 }
 function loadSetupState5() {
-  const projectPath = join51(process.cwd(), ".runwork", "setup.json");
-  const userPath = join51(homedir30(), ".runwork", "setup.json");
+  const projectPath = join52(process.cwd(), ".runwork", "setup.json");
+  const userPath = join52(homedir31(), ".runwork", "setup.json");
   for (const p of [projectPath, userPath]) {
     if (existsSync55(p)) {
       try {
@@ -24105,7 +25138,7 @@ async function checkCodexNetwork() {
   if (!state || !state.configuredAgents.includes("codex")) {
     return { name, status: "skip", message: "Codex not configured for Runwork" };
   }
-  const configPath = join51(homedir30(), ".codex", "config.toml");
+  const configPath = join52(homedir31(), ".codex", "config.toml");
   if (!existsSync55(configPath)) {
     return { name, status: "skip", message: "no Codex config found" };
   }
@@ -24164,7 +25197,7 @@ async function checkCodexDesktopProject() {
   if (!usesCodex) {
     return { name, status: "skip", message: "Codex not configured for Runwork" };
   }
-  const statePath2 = join51(homedir30(), ".codex", ".codex-global-state.json");
+  const statePath2 = join52(homedir31(), ".codex", ".codex-global-state.json");
   if (!existsSync55(statePath2)) {
     return { name, status: "skip", message: "Codex desktop app not detected" };
   }
@@ -24176,7 +25209,7 @@ async function checkCodexDesktopProject() {
   } catch {
     return { name, status: "warn", message: "could not read Codex desktop state" };
   }
-  const runworkDir = join51(homedir30(), ".runwork");
+  const runworkDir = join52(homedir31(), ".runwork");
   if (savedRoots.includes(runworkDir)) {
     return { name, status: "pass", message: "Runwork project added to Codex desktop sidebar" };
   }
@@ -24254,7 +25287,7 @@ async function checkAgentSetup() {
     if (!skillsDir)
       continue;
     const missingSkills = state.skills.filter((name) => {
-      const skillPath = join51(skillsDir, name, "SKILL.md");
+      const skillPath = join52(skillsDir, name, "SKILL.md");
       return !existsSync55(skillPath);
     });
     if (missingSkills.length > 0) {
@@ -24280,25 +25313,25 @@ async function checkAgentSetup() {
   };
 }
 function getMcpConfigPath2(slug, scope) {
-  const home = homedir30();
+  const home = homedir31();
   switch (slug) {
     case "claude-code":
-      return scope === "project" ? join51(process.cwd(), ".mcp.json") : join51(home, ".claude", "settings.json");
+      return scope === "project" ? join52(process.cwd(), ".mcp.json") : join52(home, ".claude", "settings.json");
     case "cursor":
-      return scope === "project" ? join51(process.cwd(), ".cursor", "mcp.json") : join51(home, ".cursor", "mcp.json");
+      return scope === "project" ? join52(process.cwd(), ".cursor", "mcp.json") : join52(home, ".cursor", "mcp.json");
     case "windsurf":
-      return scope === "project" ? join51(process.cwd(), ".windsurf", "mcp.json") : join51(home, ".windsurf", "mcp.json");
+      return scope === "project" ? join52(process.cwd(), ".windsurf", "mcp.json") : join52(home, ".windsurf", "mcp.json");
     case "codex":
     case "codex-app":
-      return scope === "user" ? join51(home, ".codex", "config.toml") : null;
+      return scope === "user" ? join52(home, ".codex", "config.toml") : null;
     case "gemini":
-      return scope === "user" ? join51(home, ".gemini", "settings.json") : null;
+      return scope === "user" ? join52(home, ".gemini", "settings.json") : null;
     default:
       return null;
   }
 }
 async function checkWorkspacePointers() {
-  const userStatePath = join51(homedir30(), ".runwork", "setup.json");
+  const userStatePath = join52(homedir31(), ".runwork", "setup.json");
   const state = existsSync55(userStatePath) ? (() => {
     try {
       return JSON.parse(readFileSync45(userStatePath, "utf-8"));
@@ -24331,15 +25364,15 @@ async function checkWorkspacePointers() {
   };
 }
 function getSkillsDir(slug, scope) {
-  const home = homedir30();
+  const home = homedir31();
   switch (slug) {
     case "claude-code":
-      return scope === "project" ? join51(process.cwd(), ".claude", "skills") : join51(home, ".claude", "skills");
+      return scope === "project" ? join52(process.cwd(), ".claude", "skills") : join52(home, ".claude", "skills");
     case "codex":
     case "codex-app":
-      return scope === "project" ? join51(process.cwd(), ".agents", "skills") : join51(home, ".agents", "skills");
+      return scope === "project" ? join52(process.cwd(), ".agents", "skills") : join52(home, ".agents", "skills");
     case "gemini":
-      return scope === "project" ? join51(process.cwd(), ".gemini", "skills") : join51(home, ".gemini", "skills");
+      return scope === "project" ? join52(process.cwd(), ".gemini", "skills") : join52(home, ".gemini", "skills");
     default:
       return null;
   }
@@ -24393,7 +25426,7 @@ async function runAllChecks(options) {
 init_credentials();
 init_remote();
 import { existsSync as existsSync56 } from "fs";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 async function applyDoctorFixes(ctx, failingNames) {
   const failing = new Set(failingNames);
   const outcomes = [];
@@ -24420,7 +25453,7 @@ async function applyDoctorFixes(ctx, failingNames) {
         applied: false,
         message: "no project config -- run inside an app directory"
       });
-    } else if (!existsSync56(join52(ctx.cwd, ".git"))) {
+    } else if (!existsSync56(join53(ctx.cwd, ".git"))) {
       outcomes.push({
         name: "git-remote",
         applied: false,
@@ -24440,9 +25473,9 @@ async function applyDoctorFixes(ctx, failingNames) {
 
 // src/agents/runtime-detection.ts
 import { existsSync as existsSync57, readFileSync as readFileSync46, statSync as statSync10, readdirSync as readdirSync16 } from "fs";
-import { homedir as homedir31 } from "os";
-import { join as join53 } from "path";
-var RUNWORK_SESSIONS_DIR = join53(homedir31(), ".runwork", "sessions");
+import { homedir as homedir32 } from "os";
+import { join as join54 } from "path";
+var RUNWORK_SESSIONS_DIR = join54(homedir32(), ".runwork", "sessions");
 function detectCurrentAgent() {
   const claudeCodeSessionId = process.env.CLAUDE_CODE_SESSION_ID;
   if (claudeCodeSessionId) {
@@ -24505,7 +25538,7 @@ function detectCurrentAgent() {
   return null;
 }
 function readHookSessionInfo(sessionId) {
-  const path4 = join53(RUNWORK_SESSIONS_DIR, `${sessionId}.json`);
+  const path4 = join54(RUNWORK_SESSIONS_DIR, `${sessionId}.json`);
   if (!existsSync57(path4))
     return null;
   try {
@@ -24517,7 +25550,7 @@ function readHookSessionInfo(sessionId) {
   }
 }
 function findClaudeCodeSessionFile(sessionId) {
-  const root = join53(homedir31(), ".claude", "projects");
+  const root = join54(homedir32(), ".claude", "projects");
   if (!existsSync57(root))
     return null;
   let projectDirs;
@@ -24527,14 +25560,14 @@ function findClaudeCodeSessionFile(sessionId) {
     return null;
   }
   for (const dir of projectDirs) {
-    const candidate = join53(root, dir, `${sessionId}.jsonl`);
+    const candidate = join54(root, dir, `${sessionId}.jsonl`);
     if (existsSync57(candidate))
       return candidate;
   }
   return null;
 }
 function findCodexRolloutFile(threadId) {
-  const root = join53(homedir31(), ".codex", "sessions");
+  const root = join54(homedir32(), ".codex", "sessions");
   if (!existsSync57(root))
     return null;
   const stack = [root];
@@ -24547,7 +25580,7 @@ function findCodexRolloutFile(threadId) {
       continue;
     }
     for (const entry of entries) {
-      const full = join53(dir, entry);
+      const full = join54(dir, entry);
       let s;
       try {
         s = statSync10(full);
@@ -24564,7 +25597,7 @@ function findCodexRolloutFile(threadId) {
   return null;
 }
 function findNewestClaudeCodeSession() {
-  const root = join53(homedir31(), ".claude", "projects");
+  const root = join54(homedir32(), ".claude", "projects");
   if (!existsSync57(root))
     return null;
   let projectDirs;
@@ -24575,7 +25608,7 @@ function findNewestClaudeCodeSession() {
   }
   let best = null;
   for (const dir of projectDirs) {
-    const projectPath = join53(root, dir);
+    const projectPath = join54(root, dir);
     let files;
     try {
       files = readdirSync16(projectPath);
@@ -24585,7 +25618,7 @@ function findNewestClaudeCodeSession() {
     for (const file of files) {
       if (!file.endsWith(".jsonl"))
         continue;
-      const full = join53(projectPath, file);
+      const full = join54(projectPath, file);
       try {
         const s = statSync10(full);
         if (!best || s.mtimeMs > best.mtime) {
@@ -24603,7 +25636,7 @@ function findNewestClaudeCodeSession() {
   return best ? { sessionId: best.sessionId, path: best.path } : null;
 }
 function findNewestCodexRollout() {
-  const root = join53(homedir31(), ".codex", "sessions");
+  const root = join54(homedir32(), ".codex", "sessions");
   if (!existsSync57(root))
     return null;
   const stack = [root];
@@ -24617,7 +25650,7 @@ function findNewestCodexRollout() {
       continue;
     }
     for (const entry of entries) {
-      const full = join53(dir, entry);
+      const full = join54(dir, entry);
       let s;
       try {
         s = statSync10(full);
@@ -24850,9 +25883,9 @@ init_client();
 init_resolve();
 import { Command as Command35 } from "commander";
 import { readFileSync as readFileSync47, writeFileSync as writeFileSync31, existsSync as existsSync58, mkdtempSync as mkdtempSync4 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 import { tmpdir as tmpdir4 } from "os";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 
 // src/agents/utils/transcript-render.ts
 init_session_digest();
@@ -24977,8 +26010,8 @@ function resolveLocalSessionShare(opts, conversation) {
     console.error("Error: this conversation has no shareable content.");
     process.exit(1);
   }
-  const tempDir = mkdtempSync4(join54(tmpdir4(), "runwork-share-"));
-  const transcriptFile = join54(tempDir, "transcript.md");
+  const tempDir = mkdtempSync4(join55(tmpdir4(), "runwork-share-"));
+  const transcriptFile = join55(tempDir, "transcript.md");
   writeFileSync31(transcriptFile, markdown);
   opts.transcriptFile = transcriptFile;
   opts.nativeFile = opts.nativeFile ?? conversation.transcriptPath;
@@ -24996,7 +26029,7 @@ function nativeBundleFormatForAgent(slug) {
   return null;
 }
 function sha256Hex(content) {
-  return createHash5("sha256").update(content, "utf8").digest("hex");
+  return createHash6("sha256").update(content, "utf8").digest("hex");
 }
 function utf8ByteLength(content) {
   return Buffer.byteLength(content, "utf8");
@@ -25188,8 +26221,8 @@ init_resolve();
 init_registry_data();
 import { Command as Command38 } from "commander";
 import { writeFileSync as writeFileSync32, mkdirSync as mkdirSync28, realpathSync } from "fs";
-import { homedir as homedir32 } from "os";
-import { join as join55 } from "path";
+import { homedir as homedir33 } from "os";
+import { join as join56 } from "path";
 import { spawn as spawn5 } from "child_process";
 init_registry();
 init_which();
@@ -25228,9 +26261,9 @@ function extractCodexUuid(rolloutContent) {
 }
 function placeClaudeJsonl(uuid, content, recipientCwd) {
   const encoded = encodeClaudeCodeCwd(recipientCwd);
-  const projectDir = join55(homedir32(), ".claude", "projects", encoded);
+  const projectDir = join56(homedir33(), ".claude", "projects", encoded);
   mkdirSync28(projectDir, { recursive: true });
-  const placedAt = join55(projectDir, `${uuid}.jsonl`);
+  const placedAt = join56(projectDir, `${uuid}.jsonl`);
   writeFileSync32(placedAt, content);
   return { placedAt, runFromCwd: recipientCwd };
 }
@@ -25239,10 +26272,10 @@ function placeCodexRollout(uuid, content) {
   const yyyy = String(now.getUTCFullYear());
   const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
   const dd = String(now.getUTCDate()).padStart(2, "0");
-  const dir = join55(homedir32(), ".codex", "sessions", yyyy, mm, dd);
+  const dir = join56(homedir33(), ".codex", "sessions", yyyy, mm, dd);
   mkdirSync28(dir, { recursive: true });
   const ts = now.toISOString().replace(/\.\d+Z$/, "").replace(/:/g, "-");
-  const placedAt = join55(dir, `rollout-${ts}-${uuid}.jsonl`);
+  const placedAt = join56(dir, `rollout-${ts}-${uuid}.jsonl`);
   writeFileSync32(placedAt, content);
   return { placedAt };
 }