@intentic/sandbox-contract 1.176.3 → 1.209.0

package/dist/schemas.js

@@ -1,26 +1,60 @@
-import { ExtensionManifestSchema } from "@intentic/extension-api";
+import { STATE_DIR } from "@intentic/constants";
+import { ExtensionManifestSchema } from "@intentic/extension-manifest";
 import { RegistryEntrySchema } from "@intentic/registry";
 import { z } from "zod";
+import { OutputFieldsSchema } from "./output-fields.js";
 export const OkSchema = z.object({ ok: z.literal(true) });
+export const MemberRoleSchema = z.enum(["viewer", "collaborator", "maintainer", "owner"]);
+export const GrantedRoleSchema = z.enum(["viewer", "collaborator", "maintainer"]);
+const MEMBER_ROLE_RANK = { viewer: 0, collaborator: 1, maintainer: 2, owner: 3 };
+export const roleAtLeast = (role, floor) => MEMBER_ROLE_RANK[role] >= MEMBER_ROLE_RANK[floor];
 export const RepoParamSchema = z.object({ repo: z.string() });
-export const SessionTranscriptMessageSchema = z.object({ role: z.enum(["user", "assistant"]), text: z.string() });
 export const NATIVE_PROVIDERS = ["claude", "codex", "grok", "kimi", "gemini"];
 export const AgentProviderSchema = z.string().min(1);
+export const NativeProviderParamSchema = z.object({ provider: z.enum(NATIVE_PROVIDERS) });
 export const AgentHarnessSchema = z.enum(["native", "claude-code"]);
+export const RepoBaseSchema = z.object({ repo: z.string(), base: z.string().min(1) });
 export const EditorContextSchema = z.object({
     file: z.string().min(1),
     startLine: z.number().int().min(1).optional(),
     endLine: z.number().int().min(1).optional(),
     selection: z.string().max(20_000).optional(),
 });
-const ConversationIdSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/);
+export const ConversationIdSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/);
+const entryId = z
+    .string()
+    .min(1)
+    .max(60)
+    .regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/);
 export const AgentOriginSchema = z.object({
     automationId: z.string(),
     provider: z.string(),
     channelId: z.string().optional(),
     author: z.string().optional(),
 });
+export const WakeSourceSchema = z.enum(["schedule", "event", "listener", "webchat", "workspace", "workflow"]);
+export const AdmissionRuleSchema = z.enum(["allow", "hold", "deny"]);
+export const CommandClassSchema = z.enum([
+    "git.destructive",
+    "files.destructive",
+    "secrets.access",
+    "package.publish",
+    "network.outbound",
+]);
+export const AdmissionPolicySchema = z.object({
+    schedule: AdmissionRuleSchema.default("allow"),
+    event: AdmissionRuleSchema.default("allow"),
+    listener: AdmissionRuleSchema.default("allow"),
+    webchat: AdmissionRuleSchema.default("allow"),
+    workspace: AdmissionRuleSchema.default("allow"),
+    workflow: z.enum(["allow", "deny"]).default("allow"),
+});
 export const PermissionModeSchema = z.enum(["default", "acceptEdits", "plan", "bypassPermissions"]);
+export const ForkedFromSchema = z.object({
+    conversationId: ConversationIdSchema,
+    index: z.number().int().nonnegative(),
+    files: z.enum(["then", "now"]),
+});
 export const AgentTurnSchema = z
     .object({
     prompt: z.string(),
@@ -29,42 +63,159 @@ export const AgentTurnSchema = z
     agent: AgentProviderSchema.optional(),
     harness: AgentHarnessSchema.optional(),
     account: z.string().optional(),
+    actsAs: entryId.optional(),
     sessionId: z.string().optional(),
     conversationId: ConversationIdSchema.optional(),
     isolated: z.boolean().optional(),
+    worktreeBase: z.array(RepoBaseSchema).min(1).max(50).optional(),
+    autoLand: z.boolean().optional(),
     origin: AgentOriginSchema.optional(),
-    history: z.array(SessionTranscriptMessageSchema).max(200).optional(),
+    forkOf: z
+        .object({
+        conversationId: ConversationIdSchema,
+        keep: z.number().int().nonnegative(),
+        files: z.enum(["then", "now"]),
+    })
+        .optional(),
     model: z.string().optional(),
+    unattended: z.boolean().optional(),
+    outsideWake: z.string().min(1).optional(),
     permissionMode: PermissionModeSchema.optional(),
     allowedTools: z.array(z.string().min(1)).optional(),
     effort: z.string().optional(),
     thinking: z.boolean().optional(),
+    fast: z.boolean().optional(),
     editorContext: EditorContextSchema.optional(),
 })
     .refine((turn) => turn.prompt.trim().length > 0 || (turn.attachments?.length ?? 0) > 0, {
     message: "prompt or attachments required",
-})
-    .refine((turn) => turn.sessionId === undefined || turn.history === undefined, {
-    message: "history and sessionId are mutually exclusive",
 })
     .refine((turn) => turn.isolated !== true || turn.conversationId !== undefined, {
     message: "isolated requires conversationId",
+})
+    .refine((turn) => turn.worktreeBase === undefined || (turn.isolated === true && turn.conversationId !== undefined), {
+    message: "worktreeBase requires an isolated conversationId",
 })
     .refine((turn) => turn.origin === undefined || turn.conversationId !== undefined, {
     message: "origin requires conversationId",
+})
+    .refine((turn) => turn.forkOf === undefined || turn.conversationId !== undefined, {
+    message: "forkOf requires conversationId",
+})
+    .refine((turn) => turn.forkOf?.files !== "then" || turn.isolated === true, {
+    message: 'forkOf.files "then" requires isolated',
 });
+export const AgentRunPickSchema = z.object({ agent: z.string().min(1), model: z.string().min(1) }).optional();
 export const StartedTurnSchema = z.object({ run: z.string() });
 export const AttachTurnSchema = z.object({
     conversationId: ConversationIdSchema,
     run: z.string().optional(),
     after: z.number().int().min(0).optional(),
 });
+export const LoopContextSchema = z.enum(["fresh", "continue"]);
+export const LoopOutputSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("none") }),
+    z.object({ kind: z.literal("claim") }),
+    z.object({ kind: z.literal("json"), fields: OutputFieldsSchema }),
+]);
+export const LoopCheckSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("command"), command: z.string().min(1) }),
+    z.object({ kind: z.literal("judge"), rubric: z.string().min(1), model: z.string().optional() }),
+]);
+export const LoopDocumentSchema = z.object({
+    done: z.boolean(),
+    reason: z.string(),
+    evidence: z.string().optional(),
+    data: z.record(z.string(), z.unknown()).optional(),
+});
+const LOOP_ITERATIONS_MAX = 50;
+export const LoopSchema = z.object({
+    conversationId: ConversationIdSchema,
+    goal: z.string().min(1),
+    prompt: z.string().min(1),
+    context: LoopContextSchema,
+    output: LoopOutputSchema,
+    checks: z.array(LoopCheckSchema),
+    maxIterations: z.number().int().min(1).max(LOOP_ITERATIONS_MAX),
+    maxSpendUsd: z.number().positive().optional(),
+    stallLimit: z.number().int().min(1),
+    isolated: z.boolean(),
+    agent: AgentProviderSchema.optional(),
+    harness: AgentHarnessSchema.optional(),
+    account: z.string().optional(),
+    model: z.string().optional(),
+    actsAs: entryId.optional(),
+    worktreeBase: z.array(RepoBaseSchema).min(1).max(50).optional(),
+    autoLand: z.boolean().optional(),
+});
+export const loopCanConverge = (loop) => loop.output.kind !== "none" || loop.checks.length > 0;
+export const LOOP_DIR = `${STATE_DIR}/artifacts/loops`;
+export const LoopIterationSchema = z.object({
+    n: z.number().int().min(1),
+    at: z.number(),
+    outcome: z.enum(["continue", "done", "error"]),
+    detail: z.string().optional(),
+    costUsd: z.number().optional(),
+    changed: z.boolean(),
+    sessionId: z.string().optional(),
+});
+export const LoopStateSchema = z.enum(["running", "done", "exhausted", "stalled", "overspent", "stopped", "error"]);
+export const LoopRecordSchema = LoopSchema.extend({
+    state: LoopStateSchema,
+    startedAt: z.number(),
+    endedAt: z.number().optional(),
+    resumed: z.number().int().min(0),
+    detail: z.string().optional(),
+    iterations: z.array(LoopIterationSchema),
+});
+export const LoopsListSchema = z.object({ loops: z.array(LoopRecordSchema) });
+export const LoopIdParamSchema = z.object({ conversationId: ConversationIdSchema });
+export const LoopDesignSchema = z.object({
+    id: entryId,
+    name: z.string().min(1).max(60),
+    description: z.string().max(280).optional(),
+    prompt: z.string().optional(),
+    context: LoopContextSchema,
+    output: LoopOutputSchema,
+    checks: z.array(LoopCheckSchema),
+    maxIterations: z.number().int().min(1).max(LOOP_ITERATIONS_MAX),
+    maxSpendUsd: z.number().positive().optional(),
+    stallLimit: z.number().int().min(1),
+});
+export const LoopDesignsListSchema = z.object({ designs: z.array(LoopDesignSchema) });
+export const LoopDesignSaveSchema = z.object({ design: LoopDesignSchema, create: z.boolean() });
+export const LoopDesignIdParamSchema = z.object({ id: entryId });
+export const loopFromDesign = (design, aim) => ({
+    conversationId: aim.conversationId,
+    goal: aim.goal,
+    prompt: design.prompt ?? "Work towards the goal above. Do the next most useful thing.",
+    context: design.context,
+    output: design.output,
+    checks: design.checks,
+    maxIterations: design.maxIterations,
+    ...(design.maxSpendUsd === undefined ? {} : { maxSpendUsd: design.maxSpendUsd }),
+    stallLimit: design.stallLimit,
+    isolated: aim.isolated,
+});
+export const loopDesignLine = (design) => {
+    const command = design.checks.find((check) => check.kind === "command");
+    const ends = command !== undefined
+        ? command.command
+        : design.checks.some((check) => check.kind === "judge")
+            ? "a reviewer agrees"
+            : design.output.kind === "none"
+                ? "nothing checks it"
+                : "the agent says so";
+    const ceilings = [`${design.maxIterations} rounds`, design.maxSpendUsd === undefined ? `` : `$${design.maxSpendUsd}`].filter((part) => part !== ``);
+    return [ends, ...ceilings].join(" · ");
+};
 export const AgentStatusSchema = z.enum([
     "idle",
     "running",
     "awaiting",
     "stopping",
     "stopped",
+    "resuming",
     "ready",
     "landed",
     "conflict",
@@ -80,22 +231,48 @@ export const AgentAttentionSchema = z.object({
     plan: z.boolean(),
     question: z.boolean(),
     permission: z.boolean(),
+    service: z.boolean(),
+    capability: z.boolean(),
     conflict: z.boolean(),
 });
+export const LandedMessageSchema = z.object({
+    subject: z.string(),
+    note: z.string().optional(),
+    breaking: z.string().optional(),
+});
+export const LandedMessageStepSchema = z.object({
+    provider: z.string().min(1),
+    model: z.string().min(1),
+    status: z.enum(["asking", "answered", "refused", "skipped"]),
+    at: z.number().optional(),
+    ms: z.number().optional(),
+    reason: z.string().optional(),
+});
+export const LandedMessageDraftSchema = z.object({
+    startedAt: z.number(),
+    steps: z.array(LandedMessageStepSchema),
+    outcome: z.enum(["written", "failed"]).optional(),
+    reason: z.string().optional(),
+    finishedAt: z.number().optional(),
+});
 export const AgentSummarySchema = z.object({
     id: z.string(),
     sessionId: z.string().optional(),
     title: z.string().optional(),
     status: AgentStatusSchema,
+    failure: z.string().optional(),
     provider: AgentProviderSchema,
     harness: AgentHarnessSchema,
     model: z.string().optional(),
     effort: z.string().optional(),
     thinking: z.boolean().optional(),
+    fast: z.boolean().optional(),
     account: z.string().optional(),
     branch: z.string().optional(),
     autoLand: z.boolean().optional(),
+    landRequested: z.object({ email: z.string(), name: z.string().optional(), at: z.number() }).optional(),
     origin: AgentOriginSchema.optional(),
+    forkedFrom: ForkedFromSchema.optional(),
     base: z.string().optional(),
     costUsd: z.number().optional(),
     inputTokens: z.number().optional(),
@@ -103,6 +280,8 @@ export const AgentSummarySchema = z.object({
     contextTokens: z.number().optional(),
     contextWindow: z.number().optional(),
     activity: AgentActivitySchema.optional(),
+    landedMessageDraft: LandedMessageDraftSchema.optional(),
+    landedMessage: LandedMessageSchema.optional(),
     startedAt: z.number().optional(),
     updatedAt: z.number(),
     seenAt: z.number().optional(),
@@ -111,18 +290,33 @@ export const AgentSummarySchema = z.object({
     toolUses: z.number().optional(),
     subagents: z.object({ running: z.number(), total: z.number() }).optional(),
     diff: z.object({ files: z.number(), insertions: z.number(), deletions: z.number() }).optional(),
+    landedPresence: z.object({ landed: z.number(), present: z.number() }).optional(),
+    loop: z
+        .object({ state: LoopStateSchema, iteration: z.number().int().min(0), maxIterations: z.number().int().min(1), goal: z.string() })
+        .optional(),
+    workflow: z
+        .object({
+        runId: z.string(),
+        name: z.string(),
+        step: z.string(),
+        index: z.number().int().min(1),
+        total: z.number().int().min(1),
+    })
+        .optional(),
     archivedAt: z.number().optional(),
 });
-export const AgentsListSchema = z.object({ agents: z.array(AgentSummarySchema), rev: z.number() });
 export const AgentIdSchema = z.object({ id: z.string().min(1) });
 export const AgentArchiveSchema = z.object({ ids: z.array(z.string().min(1)).max(500).optional() });
 export const AgentIdsSchema = z.object({ ids: z.array(z.string().min(1)).min(1).max(500) });
 export const AgentsMovedSchema = z.object({ moved: z.array(AgentSummarySchema), rev: z.number() });
 export const AgentsRemovedSchema = z.object({ removed: z.array(z.string()) });
-export const AgentSearchQuerySchema = z.object({ query: z.string().trim().min(2) });
-export const AgentMatchSchema = z.object({ id: z.string(), snippet: z.string().optional() });
+export const AgentSearchQuerySchema = z.object({ query: z.string().trim().min(2), caseSensitive: z.stringbool().optional() });
+export const SpeakerSchema = z.enum(["user", "agent"]);
+export const MatchSnippetSchema = z.object({ text: z.string(), speaker: SpeakerSchema });
+export const AgentMatchSchema = z.object({ id: z.string(), snippet: MatchSnippetSchema.optional() });
 export const AgentSearchResultSchema = z.object({ matches: z.array(AgentMatchSchema), scanned: z.number() });
 export const AgentRenameSchema = z.object({ id: z.string().min(1), title: z.string().trim().min(1).max(80) });
+export const AgentPlaceSchema = z.object({ id: z.string().min(1), text: z.string().trim().min(1).max(8_000) });
 export const AgentAutoLandSchema = z.object({ id: z.string().min(1), autoLand: z.boolean().nullable() });
 export const AgentFileDiffQuerySchema = z.object({ id: z.string().min(1), repo: z.string().min(1), path: z.string().min(1) });
 export const LandConflictReasonSchema = z.enum(["workspace", "diverged", "binary"]);
@@ -140,7 +334,13 @@ export const LandResultSchema = z.object({
     held: z.boolean().optional(),
 });
 export const LandModeSchema = z.enum(["check", "merge", "measure"]);
-export const AgentLandSchema = z.object({ id: z.string().min(1), mode: LandModeSchema.optional() });
+export const AgentSpanSchema = z.enum(["cumulative", "outstanding"]);
+export const AgentLandSchema = z.object({
+    id: z.string().min(1),
+    mode: LandModeSchema.optional(),
+    span: AgentSpanSchema.optional(),
+    force: z.boolean().optional(),
+});
 export const KeyedProviderSchema = z.enum(["codex", "grok", "kimi", "gemini"]);
 export const UsageWindowSchema = z.object({
     kind: z.string(),
@@ -154,7 +354,7 @@ export const AccountUsageSchema = z.object({
 });
 export const ProviderRefusalSchema = z.object({
     at: z.number(),
-    kind: z.enum(["limit", "auth"]),
+    kind: z.enum(["limit", "auth", "entitlement"]),
     message: z.string(),
     account: z.string().optional(),
 });
@@ -175,7 +375,6 @@ export const AgentReplySchema = z.discriminatedUnion("kind", [
         kind: z.literal("plan"),
         requestId: z.string().min(1),
         approve: z.boolean(),
-        mode: PermissionModeSchema.optional(),
         feedback: z.string().optional(),
     }),
     z.object({
@@ -190,6 +389,28 @@ export const AgentReplySchema = z.discriminatedUnion("kind", [
         decision: z.enum(["once", "always", "deny"]),
         feedback: z.string().optional(),
     }),
+    z.object({
+        kind: z.literal("browser_help"),
+        requestId: z.string().min(1),
+        helped: z.boolean(),
+        note: z.string().optional(),
+    }),
+    z.object({
+        kind: z.literal("terminal_help"),
+        requestId: z.string().min(1),
+        helped: z.boolean(),
+        note: z.string().optional(),
+    }),
+    z.object({
+        kind: z.literal("service_offer"),
+        requestId: z.string().min(1),
+        approve: z.boolean(),
+    }),
+    z.object({
+        kind: z.literal("capability_offer"),
+        requestId: z.string().min(1),
+        connect: z.boolean(),
+    }),
 ]);
 export const SteerSchema = z
     .object({
@@ -208,6 +429,7 @@ export const RateLimitInfoSchema = z.object({
     rateLimitType: z.string().optional(),
     utilization: z.number().optional(),
 });
+export const FastModeStateSchema = z.enum(["off", "cooldown", "on"]);
 export const OauthAccountSchema = z.object({
     id: z.string(),
     label: z.string(),
@@ -220,6 +442,7 @@ export const OauthAccountSchema = z.object({
     usage: AccountUsageSchema.optional(),
 });
 export const OauthAccountListSchema = z.object({ accounts: z.array(OauthAccountSchema) });
+export const AccountListQuerySchema = z.object({ force: z.stringbool().default(false) });
 export const AccountIdSchema = z.object({ id: z.string().min(1) });
 export const AccountRenameSchema = z.object({ id: z.string().min(1), label: z.string().max(80) });
 export const OauthExchangeSchema = z.object({
@@ -255,42 +478,110 @@ export const SessionSummarySchema = z.object({
     id: z.string(),
     title: z.string(),
     updatedAt: z.number(),
-    snippet: z.string().optional(),
+    snippet: MatchSnippetSchema.optional(),
 });
 export const SessionsListSchema = z.object({ sessions: z.array(SessionSummarySchema) });
 export const SystemPromptModeSchema = z.enum(["intentic", "claude", "custom"]);
 export const BuiltinPromptSchema = z.object({ base: z.enum(["intentic", "claude"]) });
+export const RuleMomentSchema = z.enum([
+    "turn.ending",
+    "push.starting",
+    "agent.finished",
+]);
+export const RuleBuiltinSchema = z.enum(["verify-edits"]);
+export const RuleActionSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("command"),
+        command: z.string().max(500),
+        timeoutMs: z.number().min(60_000).max(3_600_000).default(900_000),
+    }),
+    z.object({ kind: z.literal("instruct"), text: z.string().min(1).max(4000) }),
+    z.object({ kind: z.literal("verdict"), verdict: z.enum(["allow", "hold"]) }),
+    z.object({ kind: z.literal("builtin"), name: RuleBuiltinSchema }),
+]);
+export const RuleConditionSchema = z.object({
+    repo: z.string().min(1).optional(),
+    paths: z.array(z.string().min(1)).max(20).optional(),
+    outcome: z.array(z.enum(["clean", "error", "conflict"])).optional(),
+});
+const MOMENT_ACTIONS = {
+    "turn.ending": ["builtin", "instruct", "command"],
+    "push.starting": ["command"],
+    "agent.finished": ["verdict"],
+};
+export const RuleSchema = z
+    .object({
+    id: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    label: z.string().min(1).max(80),
+    moment: RuleMomentSchema,
+    when: RuleConditionSchema.optional(),
+    action: RuleActionSchema,
+    enabled: z.boolean().default(true),
+})
+    .refine((rule) => MOMENT_ACTIONS[rule.moment].includes(rule.action.kind), {
+    message: "that action cannot stand at that moment",
+    path: ["action"],
+});
+export const RuleFiringsSchema = z.record(z.string(), z.number());
+export const SkillOriginSchema = z.enum(["builtin", "own", "capability", "extension", "plugin", "persona", "dropped"]);
+export const SkillNameSchema = z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "a skill name is lowercase letters, digits and dashes");
+export const SkillSummarySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    origin: SkillOriginSchema,
+    owner: z.string().optional(),
+    enabled: z.boolean(),
+    switchable: z.boolean(),
+    editable: z.boolean(),
+    removable: z.boolean(),
+});
+export const SkillsListSchema = z.array(SkillSummarySchema);
+export const SkillBodySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    body: z.string(),
+});
+export const SkillIdSchema = z.object({ id: z.string().min(1) });
+export const SkillDraftSchema = z.object({
+    name: SkillNameSchema,
+    description: z.string().min(1).max(1024),
+    body: z.string().min(1),
+});
+export const SkillRemoveSchema = z.object({ name: SkillNameSchema });
 export const SandboxSettingsSchema = z.object({
     stableSystemPrompt: z.boolean().default(false),
-    skills: z.array(z.string()).default([]),
+    skills: z.array(z.string()).default(["lsp"]),
     hashlineEdits: z.boolean().default(false),
     terseOutput: z.boolean().default(false),
     terseHoldout: z.number().min(0).max(1).default(0),
     systemPromptMode: SystemPromptModeSchema.default("intentic"),
     systemPrompt: z.string().max(20000).default(""),
     iqSearch: z.boolean().default(false),
+    iqSearchHoldout: z.number().min(0).max(1).default(0),
     iqContext: z.boolean().default(false),
     iqContextHoldout: z.number().min(0).max(1).default(0),
     outputCleaners: z.string().default("off"),
     outputHoldout: z.number().min(0).max(1).default(0),
-    filterBackend: z.enum(["native", "rtk"]).default("native"),
-    quickModel: z.string().default(""),
+    quickModel: z.array(z.string()).max(10).default([]),
+    changelogRepos: z.array(z.string()).max(50).default([]),
+    agentRunModels: z.array(z.string()).max(10).default([]),
+    agentRunEffort: z.string().default(""),
     agentRetentionDays: z.number().min(0).max(365).default(3),
-    autoLand: z.boolean().default(true),
-    resumeAfterOutage: z.boolean().default(true),
-    autoResumeOnRestart: z.boolean().default(true),
-    prepushCommand: z.string().max(500).default(""),
-    prepushTimeoutMs: z.number().min(60_000).max(3_600_000).default(900_000),
-    prepushFixModel: z.string().default(""),
-    prepushFixEffort: z.string().default(""),
-    verifyOnStop: z.boolean().default(false),
+    resumeAfterOutage: z.boolean().default(false),
+    autoResumeOnRestart: z.boolean().default(false),
+    rules: z.array(RuleSchema).max(50).default([]),
     automationFailureLimit: z.number().min(0).max(20).default(0),
+    admission: AdmissionPolicySchema.prefault({}),
+    actionRules: z.record(z.string(), AdmissionRuleSchema).default({}),
+    commandRules: z.partialRecord(CommandClassSchema, AdmissionRuleSchema).default({}),
+    subagentsAtOnce: z.number().min(1).max(200).default(20),
+    subagentsPerTurn: z.number().min(1).max(2000).default(200),
+    subagentDepth: z.number().min(1).max(10).default(3),
 });
 export const BuiltinPromptTextSchema = z.object({ text: z.string(), version: z.string() });
 export const SavingsStageSchema = z.object({ id: z.string(), commands: z.number(), savedTokens: z.number() });
 export const InputSavingsSchema = z.object({
-    source: z.enum(["native", "rtk"]).default("native"),
-    windowed: z.boolean(),
     updatedAt: z.number().optional(),
     commands: z.number(),
     rawTokens: z.number(),
@@ -298,22 +589,31 @@ export const InputSavingsSchema = z.object({
     savedPct: z.number(),
     perCleaner: z.array(SavingsStageSchema),
     holdout: z.object({ cleaned: z.number(), heldOut: z.number(), measuredSavedPct: z.number().optional() }),
-    gaps: z.array(z.object({ command: z.string(), tokens: z.number() })),
+    gaps: z.array(z.object({ command: z.string(), commands: z.number(), tokens: z.number() })),
 });
 export const SavingsArmSchema = z.object({ turns: z.number(), mean: z.number() });
-export const TurnExperimentSchema = z.object({
-    metric: z.enum(["proseChars", "costUsd"]),
+export const IqContextOutcomeSchema = z.enum(["note", "ineligible", "deadline", "indexing", "no-hits", "failed"]);
+export const TurnMetricReadingSchema = z.object({
+    metric: z.enum(["proseChars", "searchCalls", "openingSearches"]),
     on: SavingsArmSchema,
     off: SavingsArmSchema,
-    deliveredPct: z.number().optional(),
-    minTurns: z.number(),
+    controlTurnsNeeded: z.number().optional(),
     marginPct: z.number().optional(),
     deltaPct: z.number().optional(),
     saved: z.number().optional(),
 });
+export const TurnExperimentSchema = z.object({
+    metrics: z.tuple([TurnMetricReadingSchema], TurnMetricReadingSchema),
+    minTurns: z.number(),
+    sampleUnit: z.enum(["turns", "conversations"]).optional(),
+    cohort: z.string().optional(),
+    deliveredPct: z.number().optional(),
+    outcomes: z.array(z.object({ outcome: IqContextOutcomeSchema, turns: z.number() })).optional(),
+});
 export const SavingsReportSchema = z.object({
     input: InputSavingsSchema,
     output: TurnExperimentSchema.optional(),
+    search: TurnExperimentSchema.optional(),
     context: TurnExperimentSchema.optional(),
 });
 export const IntenticRunSchema = z.object({ args: z.array(z.string()) });
@@ -334,17 +634,7 @@ export const GitFileDiffQuerySchema = RepoParamSchema.extend({ path: z.string().
 export const GitStatusSchema = z.object({ branch: z.string(), dirty: z.boolean(), files: z.array(z.string()) });
 export const GitFilesSchema = z.object({ files: z.array(z.string()) });
 export const GitFileSchema = z.object({ path: z.string(), content: z.string() });
-export const CommitResultSchema = z.object({ committed: z.boolean() });
 export const RepoPathsSchema = z.object({ repo: z.string().min(1), paths: z.array(z.string().min(1)).max(500).optional() });
-export const CommitMessageDraftSchema = z.object({
-    repos: z.array(RepoPathsSchema).min(1).max(50),
-    all: z.boolean().optional(),
-});
-export const CommitMessageSchema = z.object({
-    message: z.string(),
-    provider: z.string(),
-    model: z.string(),
-});
 export const GitChangeSchema = z.object({
     path: z.string(),
     status: z.enum(["added", "modified", "deleted", "renamed", "type-changed", "conflicted"]),
@@ -372,17 +662,21 @@ export const GitBranchSchema = z.object({
     gone: z.boolean().optional(),
     at: z.number(),
 });
-export const GitBranchesSchema = z.object({ branches: z.array(GitBranchSchema) });
+export const GitRemoteBranchSchema = z.object({ name: z.string(), remote: z.string(), branch: z.string(), at: z.number() });
+export const GitBranchesSchema = z.object({ branches: z.array(GitBranchSchema), remotes: z.array(GitRemoteBranchSchema) });
 export const GitBranchCreateAtSchema = RepoParamSchema.extend({
     name: RefNameSchema,
     start: z.string().min(1).optional(),
     checkout: z.boolean().optional(),
 });
 export const GitBranchDeleteSchema = RepoParamSchema.extend({ name: RefNameSchema, force: z.boolean().optional() });
+export const GitOperationSchema = z.enum(["merge", "rebase", "cherry-pick", "revert"]);
+export const GitOperationStateSchema = z.object({ repo: z.string(), operation: GitOperationSchema.optional() });
 export const RepoChangesSchema = z.object({
     repo: z.string(),
     branch: z.string().optional(),
     conflicted: z.array(GitChangeSchema),
+    operation: GitOperationSchema.optional(),
     staged: z.array(GitChangeSchema),
     unstaged: z.array(GitChangeSchema),
     truncated: z.number().optional(),
@@ -393,16 +687,27 @@ export const RepoChangesSchema = z.object({
 export const OriginAgentSchema = z.object({
     title: z.string().optional(),
     provider: AgentProviderSchema,
+    landedMessage: LandedMessageSchema.optional(),
 });
 export const GitChangesSchema = z.object({
     repos: z.array(RepoChangesSchema),
     originAgents: z.record(z.string(), OriginAgentSchema).optional(),
+    committing: z.array(z.string()).optional(),
+});
+export const CommitResultSchema = z.object({
+    committed: z.boolean(),
+    changes: RepoChangesSchema.optional(),
+    originAgents: z.record(z.string(), OriginAgentSchema).optional(),
 });
+export const WorkspaceModuleSchema = z.object({ dir: z.string(), name: z.string() });
+export const RepoModulesSchema = z.object({ repo: z.string(), modules: z.array(WorkspaceModuleSchema) });
+export const WorkspaceModulesSchema = z.object({ repos: z.array(RepoModulesSchema) });
 export const AgentChangeSchema = GitChangeSchema.extend({ landed: z.boolean() });
 export const AgentRepoChangesSchema = z.object({
     repo: z.string(),
     branch: z.string().optional(),
     changes: z.array(AgentChangeSchema),
+    modules: z.array(WorkspaceModuleSchema),
 });
 export const AgentChangesSchema = z.object({ repos: z.array(AgentRepoChangesSchema), conflicts: z.array(LandConflictSchema).optional() });
 const ShaSchema = z.string().regex(/^[0-9a-f]{4,64}$/);
@@ -418,8 +723,16 @@ export const GitCommitSchema = z.object({
     refs: z.array(z.string()),
     head: z.boolean(),
 });
-export const GitLogSchema = z.object({ repo: z.string(), branch: z.string().optional(), commits: z.array(GitCommitSchema) });
-export const GitLogQuerySchema = RepoParamSchema.extend({ limit: z.coerce.number().int().positive().max(2000).optional() });
+export const GitLogSchema = z.object({
+    repo: z.string(),
+    branch: z.string().optional(),
+    commits: z.array(GitCommitSchema),
+    hasMore: z.boolean(),
+});
+export const GitLogQuerySchema = RepoParamSchema.extend({
+    limit: z.coerce.number().int().positive().max(2000).optional(),
+    skip: z.coerce.number().int().nonnegative().max(1_000_000).optional(),
+});
 export const GitReposSchema = z.object({ repos: z.array(z.string()) });
 export const GitCommitDiffQuerySchema = RepoParamSchema.extend({ sha: ShaSchema });
 export const GitCommitDiffSchema = z.object({ files: z.array(GitChangeSchema) });
@@ -427,9 +740,37 @@ export const GitCommitFileDiffQuerySchema = RepoParamSchema.extend({ sha: ShaSch
 export const GitBranchCreateSchema = RepoParamSchema.extend({ sha: ShaSchema, name: RefNameSchema });
 export const GitTagCreateSchema = RepoParamSchema.extend({ sha: ShaSchema, name: RefNameSchema });
 export const GitCheckoutSchema = RepoParamSchema.extend({ ref: RefNameSchema });
+export const GitTagDeleteSchema = RepoParamSchema.extend({ name: RefNameSchema, remote: RefNameSchema.optional() });
+export const GitTagPushSchema = RepoParamSchema.extend({ name: RefNameSchema, remote: RefNameSchema });
 export const GitResetSchema = RepoParamSchema.extend({ sha: ShaSchema, mode: z.enum(["soft", "mixed", "hard"]) });
 export const GitCommitActionSchema = RepoParamSchema.extend({ sha: ShaSchema });
 export const GitActionResultSchema = z.object({ ok: z.boolean(), reason: z.string().optional() });
+export const StashEntrySchema = z.object({
+    ref: z.string(),
+    sha: z.string(),
+    short: z.string(),
+    subject: z.string(),
+    branch: z.string().optional(),
+    at: z.number(),
+    parents: z.array(z.string()),
+});
+export const StashListSchema = z.object({ repo: z.string(), stashes: z.array(StashEntrySchema) });
+const StashRefSchema = z.string().regex(/^stash@\{\d{1,4}\}$/);
+export const StashPushSchema = RepoParamSchema.extend({ message: z.string().max(500).optional(), includeUntracked: z.boolean().optional() });
+export const StashApplySchema = RepoParamSchema.extend({ ref: StashRefSchema, pop: z.boolean().optional() });
+export const StashRefParamSchema = RepoParamSchema.extend({ ref: StashRefSchema });
+export const StashDiffQuerySchema = RepoParamSchema.extend({ ref: StashRefSchema });
+export const UndoKindSchema = z.enum(["commit", "amend", "merge", "rebase", "cherry-pick", "revert", "reset", "pull", "other"]);
+export const UndoableActionSchema = z.object({
+    kind: UndoKindSchema,
+    description: z.string(),
+    branch: z.string(),
+    sha: z.string(),
+    previousSha: z.string(),
+    changesWorkingTree: z.boolean(),
+});
+export const GitUndoStateSchema = z.object({ repo: z.string(), action: UndoableActionSchema.optional() });
+export const GitUndoSchema = RepoParamSchema.extend({ previousSha: ShaSchema, discardChanges: z.boolean().optional() });
 export const SnapshotTriggerSchema = z.enum(["turn", "interval", "pre-restore", "restore", "user"]);
 export const SnapshotSchema = z.object({
     id: z.string(),
@@ -438,6 +779,14 @@ export const SnapshotSchema = z.object({
     label: z.string().optional(),
 });
 export const SnapshotsListSchema = z.object({ snapshots: z.array(SnapshotSchema) });
+export const RewindTurnSchema = z.object({
+    conversationId: z.string().min(1),
+    index: z.number().int().nonnegative(),
+});
+export const RewindResultSchema = z.object({
+    snapshot: z.string().optional(),
+    dropped: z.number().int().nonnegative(),
+});
 export const SnapshotIdSchema = z.object({ id: z.string().min(1) });
 export const SnapshotChangeSchema = z.object({
     scope: z.string(),
@@ -456,12 +805,18 @@ export const FileDiffSchema = z.object({
     binary: z.boolean().optional(),
     truncated: z.boolean().optional(),
 });
+export const WorkspaceScopeSchema = z.object({ agent: ConversationIdSchema.optional() });
+export const WorkspaceLinkSchema = z.object({
+    to: z.string(),
+    state: z.enum(["broken", "outside"]).optional(),
+});
 export const WorkspaceTreeEntrySchema = z.object({
     name: z.string(),
     path: z.string(),
     type: z.enum(["file", "dir"]),
     size: z.number().optional(),
     ignored: z.boolean().optional(),
+    link: WorkspaceLinkSchema.optional(),
     get children() {
         return z.array(WorkspaceTreeEntrySchema).optional();
     },
@@ -471,26 +826,31 @@ export const WorkspaceTreeSchema = z.object({
     tree: z.array(WorkspaceTreeEntrySchema),
     hidden: z.number(),
 });
-export const WorkspaceChildrenQuerySchema = z.object({ path: z.string().min(1) });
+export const WorkspaceChildrenQuerySchema = WorkspaceScopeSchema.extend({ path: z.string().min(1) });
 export const WorkspaceChildrenSchema = z.object({
     entries: z.array(WorkspaceTreeEntrySchema),
     hidden: z.number(),
 });
 export const WorkspaceFileQuerySchema = z.object({ path: z.string().min(1) });
+export const WorkspaceMediaTicketQuerySchema = WorkspaceScopeSchema.extend({ path: z.string().min(1) });
 export const WorkspaceMediaTicketSchema = z.object({ ticket: z.string(), expiresAt: z.number() });
-export const WorkspaceFileReadQuerySchema = z.object({
+export const WorkspaceFileReadQuerySchema = WorkspaceScopeSchema.extend({
     path: z.string().min(1),
     offset: z.coerce.number().int().optional(),
     limit: z.coerce.number().int().min(1).optional(),
 });
-export const WorkspaceFileSchema = z.object({
+export const WorkspaceFilePresentSchema = z.object({
+    present: z.literal(true),
     path: z.string(),
     content: z.string(),
     size: z.number(),
     offset: z.number(),
     bytes: z.number(),
+    shared: z.boolean(),
 });
-export const WorkspaceResolveQuerySchema = z.object({ path: z.string().min(1).max(512) });
+export const WorkspaceFileAbsentSchema = z.object({ present: z.literal(false), path: z.string() });
+export const WorkspaceFileSchema = z.discriminatedUnion("present", [WorkspaceFilePresentSchema, WorkspaceFileAbsentSchema]);
+export const WorkspaceResolveQuerySchema = WorkspaceScopeSchema.extend({ path: z.string().min(1).max(512) });
 export const WorkspaceResolveSchema = z.object({ path: z.string().optional() });
 export const WorkspaceDirSchema = z.object({ path: z.string().min(1) });
 export const WorkspaceMoveSchema = z.object({ from: z.string().min(1), to: z.string().min(1) });
@@ -505,6 +865,7 @@ export const WorkspaceSearchQuerySchema = z.object({
     literal: z.stringbool().optional(),
     word: z.stringbool().optional(),
     caseSensitive: z.stringbool().optional(),
+    include: z.string().max(512).optional(),
     limit: z.coerce.number().int().positive().optional(),
     after: z.string().optional(),
 });
@@ -582,11 +943,12 @@ export const ProjectSetupSchema = z.object({
     manager: z.string(),
     command: z.string(),
     evidence: z.string(),
-    state: z.enum(["ready", "installing", "needs-setup", "unsupported"]),
+    state: z.enum(["ready", "installing", "needs-setup", "unsupported", "stale"]),
+    missing: z.number().optional(),
 });
 export const WorkspaceSetupSchema = z.object({ projects: z.array(ProjectSetupSchema) });
-export const WorkspaceInstallSchema = z.object({ dirs: z.array(z.string()).min(1) });
-export const WorkspaceInstallResultSchema = z.object({ started: z.array(z.string()) });
+export const WorkspaceInstallSchema = z.object({ dirs: z.array(z.string().max(500)).min(1).max(50) });
+export const WorkspaceInstallResultSchema = z.object({ queued: z.array(z.string()) });
 export const ReposListSchema = z.object({ repos: z.array(z.string()) });
 export const CloneRepoSchema = z.object({ name: z.string().min(1), cloneUrl: z.string().min(1), branch: z.string().optional() });
 export const CloneResultSchema = z.object({ name: z.string(), path: z.string() });
@@ -629,9 +991,6 @@ export const WorkspacePackageSchema = z.object({ name: z.string(), dir: z.string
 export const WorkspaceDepTypeSchema = z.enum(["prod", "dev", "peer"]);
 export const WorkspaceDepEdgeSchema = z.object({ from: z.string(), to: z.string(), type: WorkspaceDepTypeSchema });
 export const WorkspaceGraphSchema = z.object({ packages: z.array(WorkspacePackageSchema), edges: z.array(WorkspaceDepEdgeSchema) });
-export const WorkspaceModuleSchema = z.object({ dir: z.string(), name: z.string() });
-export const RepoModulesSchema = z.object({ repo: z.string(), modules: z.array(WorkspaceModuleSchema) });
-export const WorkspaceModulesSchema = z.object({ repos: z.array(RepoModulesSchema) });
 export const RepoAppsParamSchema = z.object({ repo: z.string() });
 export const AppParamSchema = z.object({
     repo: z.string(),
@@ -700,17 +1059,13 @@ export const CapabilityKindSchema = z.enum([
     "vpn",
     "docker",
     "browser",
+    "identity",
     "host",
     "agent",
     "endpoint",
 ]);
 export const CapabilityStateSchema = z.enum(["active", "pending", "error", "inactive"]);
-const entryId = z
-    .string()
-    .min(1)
-    .max(60)
-    .regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/);
-export const McpConfigSchema = z.object({ url: z.string().url(), token: z.string().optional() });
+export const McpConfigSchema = z.object({ url: z.url(), token: z.string().optional() });
 export const ServiceConfigSchema = z.object({
     service: ServiceKindSchema,
     domain: z.string().min(1),
@@ -720,7 +1075,7 @@ export const ServiceConfigSchema = z.object({
 export const IntegrationConfigSchema = z.object({ provider: z.literal("stripe") });
 export const CliConfigSchema = z.object({ provider: z.string().min(1) }).catchall(z.string());
 export const PluginConfigSchema = z.object({
-    url: z.string().url(),
+    url: z.url(),
     ref: z.string().min(1).optional(),
     path: z
         .string()
@@ -730,7 +1085,7 @@ export const PluginConfigSchema = z.object({
     token: z.string().min(1).optional(),
 });
 export const ExtensionConfigSchema = z.object({
-    url: z.string().url(),
+    url: z.url(),
     ref: z.string().regex(/^[0-9a-f]{40}$/, "ref must be a full 40-character commit sha"),
     path: z
         .string()
@@ -738,6 +1093,8 @@ export const ExtensionConfigSchema = z.object({
         .refine((value) => !value.split("/").includes(".."), { message: "path must stay inside the checkout" })
         .optional(),
     token: z.string().min(1).optional(),
+    tier: z.enum(["free", "premium"]).optional(),
+    registry: z.url().optional(),
 });
 export const SshConfigSchema = z.discriminatedUnion("auth", [
     z.object({
@@ -788,21 +1145,52 @@ export const IpsecVpnConfigSchema = z.object({
     pfs: z.enum(["on", "off"]).default("on"),
     dhGroup: z.enum(["2", "5", "14", "15", "16", "19", "20"]).default("14"),
     aggressive: z.enum(["on", "off"]).default("on"),
+    routedNetworks: z
+        .string()
+        .default("0.0.0.0/0")
+        .refine((value) => value
+        .split(",")
+        .map((entry) => entry.trim())
+        .every((entry) => z.cidrv4().safeParse(entry).success || z.cidrv6().safeParse(entry).success), {
+        message: "Routed networks is a comma-separated list of CIDRs, like 10.0.0.0/8,192.168.0.0/16. A single host needs its prefix too (192.168.0.168/32). Leave it at 0.0.0.0/0 to send everything through the gateway.",
+    }),
     autoConnect,
 });
 export const VpnConfigSchema = z.discriminatedUnion("provider", [WireguardVpnConfigSchema, FortinetVpnConfigSchema, IpsecVpnConfigSchema]);
-export const BrowserPlatformSchema = z.enum(["reddit", "x", "youtube"]);
-export const BrowserConfigSchema = z.object({ platform: BrowserPlatformSchema });
-export const HostPlatformSchema = z.enum(["windows", "linux"]);
+export const DockerConfigSchema = z.object({
+    gpu: z.enum(["on", "off"]).default("off"),
+    registryMirror: z.url().optional(),
+    insecureRegistries: z.string().optional(),
+    addressPool: z.string().optional(),
+});
+export const BrowserConfigSchema = z
+    .object({
+    platform: z.string().min(1),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    identity: z.string().optional(),
+    purpose: z.string().optional(),
+    openedAt: z.string().optional(),
+})
+    .catchall(z.string());
+export const IdentityConfigSchema = z.object({
+    email: z.string().min(3),
+    password: z.string().optional(),
+    mailbox: z.string().optional(),
+    loginUrl: z.url().optional(),
+    openAccounts: z.enum(["on", "off"]).default("off"),
+});
 const hostScope = z.enum(["on", "off"]);
 export const HostScopesSchema = z.object({
     shell: hostScope.default("on"),
     write: hostScope.default("off"),
     screen: hostScope.default("on"),
     control: hostScope.default("off"),
+    sandboxes: hostScope.default("off"),
+    sandboxRemove: hostScope.default("off"),
     roots: z.string().optional(),
 });
-export const HostConfigSchema = HostScopesSchema.extend({ platform: HostPlatformSchema });
+export const HostConfigSchema = HostScopesSchema.extend({ platform: z.string().min(1) });
 export const AcpAgentConfigSchema = z.object({
     command: z.string().min(1),
     name: z.string().min(1).optional(),
@@ -811,7 +1199,7 @@ export const AcpAgentConfigSchema = z.object({
 });
 export const EndpointProtocolSchema = z.enum(["openai", "anthropic"]);
 export const EndpointConfigSchema = z.object({
-    baseUrl: z.string().url(),
+    baseUrl: z.url(),
     protocol: EndpointProtocolSchema.default("openai"),
     apiKey: z.string().optional(),
     headers: z.string().optional(),
@@ -827,27 +1215,116 @@ export const CapabilitySchema = z.discriminatedUnion("kind", [
     z.object({ id: entryId, kind: z.literal("extension"), config: ExtensionConfigSchema }),
     z.object({ id: entryId, kind: z.literal("ssh"), config: SshConfigSchema }),
     z.object({ id: entryId, kind: z.literal("vpn"), config: VpnConfigSchema }),
-    z.object({ id: entryId, kind: z.literal("docker"), config: z.object({}) }),
+    z.object({ id: entryId, kind: z.literal("docker"), config: DockerConfigSchema }),
     z.object({ id: entryId, kind: z.literal("browser"), config: BrowserConfigSchema }),
+    z.object({ id: entryId, kind: z.literal("identity"), config: IdentityConfigSchema }),
     z.object({ id: entryId, kind: z.literal("host"), config: HostConfigSchema }),
     z.object({ id: entryId, kind: z.literal("agent"), config: AcpAgentConfigSchema }),
     z.object({ id: entryId, kind: z.literal("endpoint"), config: EndpointConfigSchema }),
 ]);
-export const CapabilityStatusSchema = z.object({ state: CapabilityStateSchema, detail: z.string().optional() });
+export const PersonaPowersSchema = z.object({
+    files: z.enum(["none", "read", "write"]).default("write"),
+    shell: z.boolean().default(true),
+    code: z.boolean().default(true),
+    web: z.boolean().default(true),
+    browser: z.boolean().default(true),
+    delegate: z.boolean().default(true),
+    sandbox: z.boolean().default(true),
+    connectors: z.array(entryId).max(100).optional(),
+    computers: z.array(entryId).max(50).optional(),
+    mcp: z.array(entryId).max(50).optional(),
+});
+export const PersonaWorkspaceSchema = z.object({
+    startIn: z.string().max(200).optional(),
+    folders: z.array(z.string().min(1)).max(50).optional(),
+});
+export const PersonaSchema = z.object({
+    id: entryId,
+    label: z.string().max(60).optional(),
+    capabilities: z.array(entryId).max(50),
+    repos: z.array(z.string().min(1)).max(50).optional(),
+    powers: PersonaPowersSchema.optional(),
+    workspace: PersonaWorkspaceSchema.optional(),
+    systemPromptMode: SystemPromptModeSchema.optional(),
+});
+export const FRONT_DESK_PERSONA = "front-desk";
+export const personaBounds = (persona) => {
+    const powers = persona.powers;
+    if (powers === undefined) {
+        return "Full powers";
+    }
+    const resolved = PersonaPowersSchema.parse(powers);
+    if (resolved.files === "read" && !resolved.shell) {
+        return "Read-only";
+    }
+    if (!resolved.shell) {
+        return "No shell";
+    }
+    const limits = [
+        resolved.files === "none",
+        !resolved.code,
+        !resolved.web,
+        !resolved.browser,
+        !resolved.delegate,
+        !resolved.sandbox,
+        resolved.connectors !== undefined,
+        resolved.computers !== undefined,
+        resolved.mcp !== undefined,
+    ].filter(Boolean).length;
+    return limits === 0 ? "Full powers" : `${limits} limit${limits === 1 ? "" : "s"}`;
+};
+export const PersonaIdParamSchema = z.object({ id: entryId });
+export const PersonasListSchema = z.object({
+    personas: z.array(PersonaSchema),
+    connected: z.array(z.string()),
+});
+export const PersonaKitSchema = z.object({
+    prompt: z.string(),
+    skills: z.array(z.object({ name: z.string(), description: z.string() })),
+});
+export const PersonaPromptSchema = PersonaIdParamSchema.extend({ prompt: z.string().max(20000) });
+export const PersonaSkillSchema = PersonaIdParamSchema.extend(SkillDraftSchema.shape);
+export const PersonaSkillNameSchema = PersonaIdParamSchema.extend({ name: SkillNameSchema });
+export const PersonaSkillBodySchema = z.object({ name: z.string(), description: z.string(), body: z.string() });
+export const CapabilityStatusSchema = z.object({
+    state: CapabilityStateSchema,
+    detail: z.string().optional(),
+    code: z.string().optional(),
+});
 export const CapabilitySummarySchema = z.object({
     id: z.string(),
     kind: CapabilityKindSchema,
     status: CapabilityStatusSchema,
     config: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
 });
-export const CapabilityRecommendationSchema = z.object({ kind: CapabilityKindSchema, evidence: z.string() });
+export const CapabilityRecommendationSchema = z.object({
+    card: z.string(),
+    evidence: z.string(),
+    reason: z.string(),
+    prefill: z.record(z.string(), z.string()),
+});
 export const CapabilitiesListSchema = z.object({
     capabilities: z.array(CapabilitySummarySchema),
     recommendations: z.array(CapabilityRecommendationSchema).default([]),
 });
 export const CapabilityIdParamSchema = z.object({ id: z.string() });
+export const CapabilityConnectionSchema = z.object({
+    id: z.string(),
+    kind: z.string(),
+    config: z.record(z.string(), z.string()),
+});
+export const CapabilityCardParamSchema = z.object({ card: z.string() });
 export const CapabilitySecretInputSchema = z.object({ id: z.string(), value: z.string().min(1) });
+export const CapabilityRenameSchema = z.object({
+    id: z.string(),
+    to: z
+        .string()
+        .min(1)
+        .max(60)
+        .regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/),
+});
 export const CapabilityLoginSchema = z.object({ session: z.string() });
+export const CapabilityOtpSchema = z.object({ code: z.string(), secondsRemaining: z.number() });
 export const HostFactsSchema = z.object({
     os: z.string(),
     arch: z.string(),
@@ -857,7 +1334,7 @@ export const HostFactsSchema = z.object({
 });
 export const HostSummarySchema = z.object({
     id: z.string(),
-    platform: HostPlatformSchema,
+    platform: z.string().min(1),
     online: z.boolean(),
     version: z.string().optional(),
     lastSeen: z.number().optional(),
@@ -903,21 +1380,91 @@ export const ForticlientConnectionSchema = z.object({
     needs: z.array(z.string()),
 });
 export const ForticlientImportSchema = z.object({ connections: z.array(ForticlientConnectionSchema) });
-export const MarketplaceRequestSchema = z.object({ url: z.string().url(), token: z.string().min(1).optional() });
+export const MarketplaceRequestSchema = z.object({ url: z.url(), token: z.string().min(1).optional() });
 export const MarketplaceSchema = z.object({ name: z.string(), plugins: z.array(RegistryEntrySchema) });
 const extensionId = z
     .string()
     .min(1)
     .max(121)
     .regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/);
+export const ExtensionUpdatePolicySchema = z.object({
+    updates: z.enum(["notify", "agent", "auto"]),
+    advisories: z.enum(["auto-disable", "notify"]),
+});
+export const ExtensionUpdateSchema = z.object({
+    ref: z.string(),
+    version: z.string().optional(),
+    url: z.string(),
+    path: z.string().optional(),
+    trust: z.enum(["verified", "listed"]),
+    securityFix: z.boolean().optional(),
+    registry: z.string(),
+    at: z.string(),
+    needsReview: z.string().optional(),
+    review: z.object({ conversationId: z.string(), at: z.string() }).optional(),
+});
+export const ExtensionAdvisorySchema = z.object({
+    reason: z.string(),
+    registry: z.string(),
+    at: z.string(),
+    autoDisabled: z.boolean(),
+});
+export const ExtensionHealthSchema = z.object({
+    state: z.enum(["watching", "healthy", "unhealthy"]),
+    detail: z.string().optional(),
+    fromRef: z.string().optional(),
+    at: z.string(),
+    autoReverted: z.boolean().optional(),
+});
+export const PowersDiffSchema = z.object({ added: z.array(z.string()), removed: z.array(z.string()), unchanged: z.array(z.string()) });
+export const ExtensionUpdateActionSchema = z.object({
+    id: extensionId,
+    ref: z
+        .string()
+        .regex(/^[0-9a-f]{40}$/)
+        .optional(),
+});
+export const ExtensionUpdatePreviewSchema = z.object({
+    ref: z.string(),
+    version: z.string(),
+    installedVersion: z.string(),
+    engines: z.string(),
+    compatible: z.boolean(),
+    powers: PowersDiffSchema,
+});
+export const ExtensionUpdateAppliedSchema = z.object({ ok: z.literal(true), ref: z.string(), rebuildNeeded: z.boolean().optional() });
+export const ExtensionUpdatePolicyInputSchema = z.object({
+    id: extensionId,
+    updates: z.enum(["notify", "agent", "auto"]).optional(),
+    advisories: z.enum(["auto-disable", "notify"]).optional(),
+});
+export const ExtensionUpdatesCheckedSchema = z.object({ ok: z.literal(true), checkedAt: z.string() });
 export const ExtensionSummarySchema = z.object({
     id: extensionId,
     manifest: ExtensionManifestSchema,
     commit: z.string(),
-    builtin: z.boolean(),
+    source: z.enum(["builtin", "installed", "workspace"]),
     enabled: z.boolean(),
+    essential: z.boolean().optional(),
+    usage: z.record(z.string(), z.object({ calls: z.number().int().nonnegative(), last: z.string() })).optional(),
+    backend: z
+        .object({
+        state: z.enum(["running", "error", "absent", "incompatible", "starting", "stopped"]),
+        detail: z.string().optional(),
+    })
+        .optional(),
+    update: ExtensionUpdateSchema.optional(),
+    advisory: ExtensionAdvisorySchema.optional(),
+    health: ExtensionHealthSchema.optional(),
+    previous: z.object({ ref: z.string(), version: z.string().optional() }).optional(),
+    updatePolicy: ExtensionUpdatePolicySchema.optional(),
+});
+export const InvalidWorkspaceExtensionSchema = z.object({ dir: z.string(), error: z.string() });
+export const ExtensionsListSchema = z.object({
+    extensions: z.array(ExtensionSummarySchema),
+    invalid: z.array(InvalidWorkspaceExtensionSchema),
+    updatesCheckedAt: z.string().optional(),
 });
-export const ExtensionsListSchema = z.object({ extensions: z.array(ExtensionSummarySchema) });
 export const ExtensionSettingsSchema = z.object({
     settings: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
     secretsSet: z.array(z.string()),
@@ -927,6 +1474,12 @@ export const ExtensionSettingsInputSchema = z.object({
     settings: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
 });
 export const ExtensionEnabledInputSchema = z.object({ id: z.string(), enabled: z.boolean() });
+export const WorkspaceExtensionCreateSchema = z.object({
+    publisher: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    name: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+});
+export const WorkspaceExtensionCreatedSchema = z.object({ id: z.string(), dir: z.string() });
+export const ExtensionUsageInputSchema = z.object({ id: z.string(), used: z.record(z.string(), z.number().int().positive()) });
 export const ExtensionProcessParamSchema = z.object({ id: z.string(), name: z.string() });
 export const ExtensionProcessStatusSchema = z.object({
     name: z.string(),
@@ -934,7 +1487,7 @@ export const ExtensionProcessStatusSchema = z.object({
     port: z.number().optional(),
     previewUrl: z.string().optional(),
 });
-export const WorkspaceEventKindSchema = z.enum(["turn.settled", "agent.landed"]);
+export const WorkspaceEventKindSchema = z.enum(["turn.settled", "agent.landed", "deps.broken", "deps.fixed"]);
 export const WorkspaceEventSchema = z.object({
     event: WorkspaceEventKindSchema,
     agentId: z.string(),
@@ -942,6 +1495,15 @@ export const WorkspaceEventSchema = z.object({
     branch: z.string(),
     outcome: z.enum(["landed", "conflict", "ready", "idle", "error"]),
     repos: z.array(z.object({ repo: z.string(), from: z.string(), dir: z.string() })),
+    deps: z
+        .object({
+        project: z.string(),
+        command: z.string(),
+        exitCode: z.number(),
+        attempt: z.number(),
+        logTail: z.string(),
+    })
+        .optional(),
 });
 export const TriggerSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("schedule"), cron: z.string().min(1) }),
@@ -952,6 +1514,7 @@ export const TriggerSchema = z.discriminatedUnion("kind", [
         channelId: z.string().min(1).optional(),
         eventType: z.string().min(1).optional(),
         mentioned: z.boolean().optional(),
+        branch: z.string().min(1).optional(),
         allowedOrigins: z.array(z.string()).optional(),
     }),
     z.object({ kind: z.literal("workspace"), event: WorkspaceEventKindSchema, repo: z.string().min(1).optional() }),
@@ -1008,9 +1571,12 @@ export const AutomationSchema = z.object({
     webchat: WebchatConfigSchema.optional(),
     allowedTools: z.array(z.string().min(1)).optional(),
     agent: AgentProviderSchema.optional(),
+    account: z.string().optional(),
+    actsAs: entryId.optional(),
     harness: AgentHarnessSchema.optional(),
     model: z.string().optional(),
     requireApproval: z.boolean().optional(),
+    holdForSeconds: z.number().optional(),
     chore: z.boolean().optional(),
     enabled: z.boolean(),
 });
@@ -1020,7 +1586,15 @@ export const AutomationApprovalSchema = z.object({
     payload: z.string().optional(),
     origin: AgentOriginSchema.optional(),
     title: z.string().optional(),
+    conversationId: z.string().optional(),
+    sessionId: z.string().optional(),
     createdAt: z.number(),
+    autoRunAt: z.number().optional(),
+});
+export const AgentsListSchema = z.object({
+    agents: z.array(AgentSummarySchema),
+    rev: z.number(),
+    held: z.array(AutomationApprovalSchema).default([]),
 });
 export const AutomationApprovalsListSchema = z.object({ approvals: z.array(AutomationApprovalSchema) });
 export const AutomationApprovalIdParamSchema = z.object({ id: z.string() });
@@ -1036,6 +1610,125 @@ export const AutomationSummarySchema = AutomationSchema.extend({
 });
 export const AutomationsListSchema = z.object({ automations: z.array(AutomationSummarySchema) });
 export const AutomationIdParamSchema = z.object({ id: z.string() });
+export const AutomationEnabledInputSchema = z.object({ id: z.string(), enabled: z.boolean() });
+const TriggerFieldSchema = z.object({ label: z.string().min(1), placeholder: z.string().min(1), hint: z.string().min(1).optional() });
+export const TriggerSourceSchema = z.object({
+    provider: z.string().min(1),
+    label: z.string().min(1),
+    logo: z.string().min(1).optional(),
+    icon: z.string().min(1).optional(),
+    events: z.array(z.object({ value: z.string().min(1), label: z.string().min(1) })),
+    channel: TriggerFieldSchema,
+    branchField: TriggerFieldSchema.optional(),
+    mentionLabel: z.string().min(1).optional(),
+    starterPrompt: z.string().min(1).optional(),
+    requires: z.array(z.string().min(1)).default([]),
+    enabled: z.boolean(),
+});
+export const TemplateOfferSchema = z.enum(["create", "configure"]);
+export const AutomationTemplateSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    logo: z.string().min(1).optional(),
+    icon: z.string().min(1).optional(),
+    requires: z.array(z.string().min(1)).default([]),
+    trigger: TriggerSchema,
+    guard: z.string().min(1).optional(),
+    holdForSeconds: z.number().int().positive().optional(),
+    prompt: z.string().min(1),
+    note: z.string().min(1).optional(),
+    setup: z.string().min(1).optional(),
+    description: z.string().min(1).optional(),
+    offer: TemplateOfferSchema.optional(),
+    chore: z.boolean().optional(),
+});
+export const AutomationCatalogSchema = z.object({
+    sources: z.array(TriggerSourceSchema),
+    templates: z.array(AutomationTemplateSchema),
+});
+const StepIdSchema = z
+    .string()
+    .min(1)
+    .max(24)
+    .regex(/^[a-z0-9][a-z0-9-]*$/);
+export const WorkflowHandoffSchema = z.enum(["fresh", "continue"]);
+const WORKFLOW_STEPS_MAX = 24;
+export const WorkflowStepSchema = z.object({
+    id: StepIdSchema,
+    title: z.string().min(1).max(60),
+    goal: z.string().min(1).optional(),
+    prompt: z.string().min(1).optional(),
+    needs: z.array(StepIdSchema),
+    handoff: WorkflowHandoffSchema,
+    output: LoopOutputSchema,
+    checks: z.array(LoopCheckSchema),
+    context: LoopContextSchema,
+    maxSpendUsd: z.number().positive().optional(),
+    agent: AgentProviderSchema.optional(),
+    harness: AgentHarnessSchema.optional(),
+    account: z.string().optional(),
+    model: z.string().optional(),
+    actsAs: entryId.optional(),
+});
+export const WorkflowGateSchema = z.object({
+    step: StepIdSchema,
+    field: z.string().min(1),
+    pass: z.array(z.string().min(1)).min(1),
+    token: z.string().optional(),
+    dailyMax: z.number().int().positive().optional(),
+});
+export const GATE_DAILY_MAX_DEFAULT = 20;
+export const GateOutcomeSchema = z.enum(["pass", "fail", "blocked"]);
+export const GateVerdictSchema = z.object({
+    outcome: GateOutcomeSchema,
+    reason: z.string(),
+    runId: z.string(),
+    value: z.string().optional(),
+});
+export const WorkflowSchema = z.object({
+    id: entryId,
+    name: z.string().min(1).max(80),
+    description: z.string().max(400).optional(),
+    steps: z.array(WorkflowStepSchema).min(1).max(WORKFLOW_STEPS_MAX),
+    gate: WorkflowGateSchema.optional(),
+    maxParallel: z.number().int().min(1).max(8),
+});
+export const WorkflowStepStateSchema = z.enum(["pending", "running", "done", "failed", "skipped", "stopped"]);
+export const WorkflowStepRunSchema = z.object({
+    stepId: StepIdSchema,
+    state: WorkflowStepStateSchema,
+    conversationId: z.string(),
+    startedAt: z.number().optional(),
+    endedAt: z.number().optional(),
+    iterations: z.number().int().min(0),
+    costUsd: z.number().optional(),
+    loopState: LoopStateSchema.optional(),
+    detail: z.string().optional(),
+    document: LoopDocumentSchema.optional(),
+    report: z.string().optional(),
+    reportPath: z.string().optional(),
+});
+export const WorkflowRunStateSchema = z.enum(["running", "done", "failed", "stopped", "overspent", "error"]);
+export const WorkflowRunSchema = z.object({
+    runId: z.string().min(1),
+    workflow: WorkflowSchema,
+    repos: z.array(RepoBaseSchema).min(1).max(50),
+    request: z.string().optional(),
+    state: WorkflowRunStateSchema,
+    startedAt: z.number(),
+    endedAt: z.number().optional(),
+    resumed: z.number().int().min(0),
+    detail: z.string().optional(),
+    steps: z.array(WorkflowStepRunSchema),
+    archivedAt: z.number().optional(),
+});
+export const WorkflowSummarySchema = WorkflowSchema.extend({ runs: z.array(WorkflowRunSchema) });
+export const WorkflowsListSchema = z.object({ workflows: z.array(WorkflowSummarySchema) });
+export const WorkflowRunsListSchema = z.object({ runs: z.array(WorkflowRunSchema) });
+export const WorkflowIdParamSchema = z.object({ id: z.string() });
+export const WorkflowRunIdParamSchema = z.object({ runId: z.string() });
+export const WorkflowRunStartSchema = WorkflowIdParamSchema.extend({ request: z.string().min(1).max(20_000).optional() });
+export const WorkflowSaveSchema = z.object({ workflow: WorkflowSchema, create: z.boolean() });
 export const CiHostSchema = z.enum(["github", "gitlab"]);
 export const PipelineStatusSchema = z.enum(["running", "success", "failed", "canceled", "skipped"]);
 export const PipelineRunSchema = z.object({
@@ -1059,6 +1752,7 @@ export const PipelineJobSchema = z.object({
     name: z.string(),
     status: PipelineStatusSchema,
     stage: z.string().optional(),
+    needs: z.array(z.string()).optional(),
     startedAt: z.number().optional(),
     finishedAt: z.number().optional(),
     durationSeconds: z.number().optional(),
@@ -1074,6 +1768,7 @@ export const CiRepoSchema = z.object({
     url: z.string(),
     hookWarning: z.string().optional(),
 });
+export const CI_POLL_INTERVAL_MS = 2 * 60_000;
 export const CiRunsResponseSchema = z.object({
     repos: z.array(CiRepoSchema),
     runs: z.array(PipelineRunSchema),
@@ -1081,90 +1776,8 @@ export const CiRunsResponseSchema = z.object({
 });
 export const CiSeenResponseSchema = z.object({ seenAt: z.number() });
 export const CiRunParamSchema = z.object({ repo: z.string(), runId: z.number() });
+export const CiFixParamSchema = CiRunParamSchema.extend({ pick: AgentRunPickSchema });
 export const CiFixResponseSchema = z.object({ conversationId: z.string() });
-export const DeployStateSchema = z.enum(["running", "deploying", "stopped", "unhealthy", "unknown"]);
-export const DeployResourceKindSchema = z.enum(["deployment", "stack"]);
-export const DeployServiceSchema = z.object({
-    name: z.string(),
-    image: z.string(),
-    updateAvailable: z.boolean(),
-});
-export const DeployResourceSchema = z.object({
-    kind: DeployResourceKindSchema,
-    id: z.string(),
-    name: z.string(),
-    state: DeployStateSchema,
-    status: z.string().optional(),
-    server: z.string().optional(),
-    image: z.string().optional(),
-    updateAvailable: z.boolean(),
-    services: z.array(DeployServiceSchema),
-    url: z.string(),
-});
-export const DeployServerStateSchema = z.enum(["ok", "unreachable", "disabled"]);
-export const DeployServerSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    state: DeployServerStateSchema,
-    cpuPercent: z.number().optional(),
-    memPercent: z.number().optional(),
-    diskPercent: z.number().optional(),
-    url: z.string(),
-});
-export const DeployAlertSchema = z.object({
-    id: z.string(),
-    type: z.string(),
-    level: z.enum(["ok", "warning", "critical"]),
-    resolved: z.boolean(),
-    ts: z.number(),
-    resource: z.string().optional(),
-    server: z.string().optional(),
-    from: z.string().optional(),
-    to: z.string().optional(),
-});
-export const DeployViewerSchema = z.object({
-    username: z.string(),
-    admin: z.boolean(),
-});
-export const DeployRepoLinkSchema = z.object({
-    repo: z.string(),
-    projectName: z.string(),
-    composePath: z.string(),
-    linkedStack: z.string().optional(),
-    suggestions: z.array(z.string()),
-});
-export const DeployLinkParamSchema = z.object({
-    capability: z.string(),
-    repo: z.string(),
-    stack: z.string(),
-});
-export const DeployOverviewResponseSchema = z.object({
-    komodoUrl: z.string(),
-    reachable: z.boolean(),
-    unreachableReason: z.string().optional(),
-    viewer: DeployViewerSchema.optional(),
-    repos: z.array(DeployRepoLinkSchema).default([]),
-    resources: z.array(DeployResourceSchema),
-    servers: z.array(DeployServerSchema),
-    alerts: z.array(DeployAlertSchema),
-    seenAt: z.number().optional(),
-});
-export const DeployCapabilityParamSchema = z.object({ capability: z.string() });
-export const DeployActionSchema = z.enum(["deploy", "restart", "start", "stop", "pull"]);
-export const DeployActionParamSchema = z.object({
-    capability: z.string(),
-    kind: DeployResourceKindSchema,
-    id: z.string(),
-    action: DeployActionSchema,
-});
-export const DeployLogsParamSchema = z.object({
-    capability: z.string(),
-    kind: DeployResourceKindSchema,
-    id: z.string(),
-});
-export const DeployLogsResponseSchema = z.object({ stdout: z.string(), stderr: z.string() });
-export const DeployFixResponseSchema = z.object({ conversationId: z.string() });
-export const DeploySeenResponseSchema = z.object({ seenAt: z.number() });
 export const PrepushStatusSchema = z.enum(["idle", "running", "passed", "failed", "error", "cancelled"]);
 export const PrepushRunSchema = z.object({
     status: PrepushStatusSchema,
@@ -1173,6 +1786,7 @@ export const PrepushRunSchema = z.object({
     finishedAt: z.number().optional(),
     exitCode: z.number().optional(),
     timedOut: z.boolean().optional(),
+    session: z.string().optional(),
     output: z.string(),
 });
 export const DraftStatusSchema = z.enum(["proposed", "approved", "posting", "posted", "failed"]);
@@ -1185,7 +1799,9 @@ export const DraftSchema = z.object({
     scheduledAt: z.number().optional(),
     status: DraftStatusSchema.default("proposed"),
     createdAt: z.number().optional(),
+    postingAt: z.number().optional(),
     postedAt: z.number().optional(),
+    postedUrl: z.string().optional(),
     error: z.string().optional(),
 });
 export const DraftSummarySchema = DraftSchema.extend({ id: entryId });
@@ -1197,6 +1813,7 @@ export const PanelSummarySchema = z.object({
     running: z.boolean(),
     healthy: z.boolean(),
     port: z.number().optional(),
+    servers: z.array(z.object({ url: z.string(), dir: z.string().optional(), session: z.string().optional() })),
     previewUrl: z.string().optional(),
     role: z.enum(["intent", "desired-state", "app"]).optional(),
     deployConfig: z.boolean(),
@@ -1205,6 +1822,7 @@ export const PanelSummarySchema = z.object({
     monorepo: z.boolean(),
     vitest: z.boolean(),
     userStories: z.boolean(),
+    docs: z.boolean(),
 });
 export const PanelsListSchema = z.object({ panels: z.array(PanelSummarySchema) });
 export const PanelRepoParamSchema = z.object({ repo: z.string() });
@@ -1216,12 +1834,126 @@ export const PortSummarySchema = z.object({
     pid: z.number().optional(),
     command: z.string().optional(),
     cwd: z.string().optional(),
+    session: z.string().optional(),
     forwarded: z.boolean(),
     previewUrl: z.string().optional(),
 });
 export const PortsListSchema = z.object({ ports: z.array(PortSummarySchema) });
 export const PortParamSchema = z.object({ port: z.number().int().min(1).max(65535) });
 export const PortForwardResultSchema = z.object({ previewUrl: z.string().optional() });
+export const MachineSandboxSchema = z.object({
+    slug: z.string(),
+    container: z.string(),
+    name: z.string().optional(),
+    running: z.boolean(),
+    image: z.string(),
+    tunnelRunning: z.boolean().optional(),
+});
+export const MachineSandboxOpSchema = z.enum(["start", "stop", "restart", "update", "rebuild", "rollback", "remove"]);
+export const MachineSandboxFlowSchema = z.object({
+    op: MachineSandboxOpSchema,
+    slug: z.string().min(1),
+    hash: z.string().optional(),
+});
+export const MachineSandboxFlowInputSchema = MachineSandboxFlowSchema.extend({ id: z.string().min(1) });
+export const MachineFlowLineSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("line"), text: z.string() }),
+    z.object({ kind: z.literal("result"), message: z.string() }),
+    z.object({ kind: z.literal("error"), message: z.string() }),
+]);
+export const MachinePairingSchema = z.object({
+    sandboxId: z.string(),
+    mode: z.enum(["sync", "mirror"]),
+    localDir: z.string().optional(),
+    mutagenStatus: z.string().optional(),
+    conflicts: z.number().int().nonnegative().optional(),
+    paused: z.boolean().optional(),
+});
+export const MachinePortStateSchema = z.enum([
+    "mirrored",
+    "held-by-sandbox",
+    "busy",
+]);
+export const MachinePortSchema = z.object({
+    port: z.number().int().min(1).max(65535),
+    host: z.enum(["127.0.0.1", "::1"]),
+    sandboxId: z.string(),
+    state: MachinePortStateSchema,
+    heldBy: z.string().optional(),
+    command: z.string().optional(),
+});
+export const MachineWatcherSchema = z.object({
+    running: z.boolean(),
+    pid: z.number().int().optional(),
+    lastTickAt: z.number().optional(),
+});
+export const MachineReportSchema = z.object({
+    hostname: z.string(),
+    os: z.string(),
+    agents: z.object({ sync: z.string().optional(), host: z.string().optional() }),
+    sandboxes: z.array(MachineSandboxSchema),
+    pairings: z.array(MachinePairingSchema),
+    ports: z.array(MachinePortSchema),
+    watcher: MachineWatcherSchema,
+    capturedAt: z.number(),
+});
+export const ComputerGapSchema = z.enum([
+    "offline",
+    "scope-off",
+    "no-agent",
+    "unreported",
+]);
+export const ComputerSchema = z.object({
+    key: z.string(),
+    label: z.string(),
+    syncEnrolled: z.boolean(),
+    hostId: z.string().optional(),
+    online: z.boolean().optional(),
+    platform: z.string().optional(),
+    facts: HostFactsSchema.optional(),
+    hostAgent: z.string().optional(),
+    lastSeen: z.number().optional(),
+    report: MachineReportSchema.optional(),
+    gap: ComputerGapSchema.optional(),
+});
+export const ComputersListSchema = z.object({ computers: z.array(ComputerSchema) });
+export const SyncStatusSchema = z.object({
+    enrolled: z.boolean(),
+    sshHostname: z.string().optional(),
+    syncingFrom: z.string().optional(),
+    syncSeenAt: z.number().optional(),
+    mirroredBy: z.array(z.string()).optional(),
+    machines: z.array(MachineReportSchema).optional(),
+});
+export const PublicFileSchema = z.object({
+    path: z.string(),
+    size: z.number(),
+    modifiedAt: z.number(),
+    url: z.string().optional(),
+    blocked: z.string().optional(),
+});
+export const PublicListSchema = z.object({ url: z.string().optional(), files: z.array(PublicFileSchema) });
+export const PublishSchema = z.object({ path: z.string().min(1) });
+export const UnpublishSchema = z.object({ path: z.string().min(1) });
+export const PublishResultSchema = z.object({ path: z.string(), url: z.string().optional() });
+export const ShareDetailSchema = z.enum(["messages", "everything"]);
+export const SharedConversationSchema = z.object({
+    id: z.string(),
+    conversationId: z.string(),
+    title: z.string(),
+    detail: ShareDetailSchema,
+    sharedAt: z.number(),
+    messages: z.number(),
+    url: z.string().optional(),
+});
+export const ShareListSchema = z.object({ shares: z.array(SharedConversationSchema) });
+export const ShareCreateSchema = z.object({
+    conversationId: z.string().min(1),
+    title: z.string().min(1).max(80),
+    detail: ShareDetailSchema,
+});
+export const ShareUpdateSchema = z.object({ id: z.string().min(1) });
+export const ShareRemoveSchema = z.object({ id: z.string().min(1) });
 export const TerminalSessionSchema = z.object({
     name: z.string(),
     label: z.string().optional(),
@@ -1231,9 +1963,20 @@ export const TerminalSessionSchema = z.object({
     exitCode: z.number().optional(),
     extensionId: z.string().optional(),
     processName: z.string().optional(),
+    help: z.object({ requestId: z.string(), message: z.string(), requestedAt: z.number() }).optional(),
 });
 export const TerminalsListSchema = z.object({ sessions: z.array(TerminalSessionSchema) });
 export const TerminalNameParamSchema = z.object({ name: z.string() });
+export const TerminalScrollbackQuerySchema = z.object({
+    name: z.string(),
+    lines: z.coerce.number().min(1).max(100_000).default(20_000),
+});
+export const TerminalScrollbackSchema = z.object({
+    name: z.string(),
+    text: z.string(),
+    lines: z.number(),
+    truncated: z.boolean(),
+});
 export const BrowserPageSchema = z.object({
     id: z.string(),
     title: z.string().optional(),
@@ -1247,12 +1990,13 @@ export const BrowserSessionSchema = z.object({
     running: z.boolean(),
     activityAt: z.number(),
     finishedAt: z.number().optional(),
+    help: z.object({ requestId: z.string(), message: z.string(), requestedAt: z.number() }).optional(),
     pages: z.array(BrowserPageSchema),
 });
 export const BrowsersListSchema = z.object({ sessions: z.array(BrowserSessionSchema) });
 export const BrowserNameParamSchema = z.object({ name: z.string() });
 export const SubagentKindSchema = z.enum(["subagent", "codex", "grok"]);
-export const SubagentStatusSchema = z.enum(["pending", "running", "completed", "failed", "killed", "paused"]);
+export const SubagentStatusSchema = z.enum(["pending", "running", "blocked", "completed", "failed", "killed", "paused"]);
 export const SubagentSessionSchema = z.object({
     id: z.string(),
     kind: SubagentKindSchema,
@@ -1284,6 +2028,23 @@ export const EnvironmentSchema = z.object({
     container: z.string().optional(),
 });
 export const EnvironmentApproveSchema = z.object({ hash: z.string().min(1) });
+const environmentToolSchema = z.object({
+    name: z.string(),
+    version: z.string().optional(),
+});
+export const EnvironmentItemSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    origin: z.enum(["custom", "capability", "base"]),
+    originLabel: z.string().optional(),
+    state: z.enum(["active", "after-rebuild", "awaiting-approval"]),
+    tools: z.array(environmentToolSchema),
+    extras: z.number().optional(),
+    purpose: z.string().optional(),
+    detail: z.string().optional(),
+    commands: z.string().optional(),
+});
+export const EnvironmentContentsSchema = z.object({ items: z.array(EnvironmentItemSchema) });
 export const BundleManifestSchema = z.object({
     version: z.literal(1),
     sandbox: z.object({ name: z.string() }).optional(),
@@ -1302,6 +2063,15 @@ export const ImportReportSchema = z.object({
     refused: z.array(z.string()),
     needsAction: z.array(z.object({ subject: z.string(), detail: z.string() })),
 });
+export const BundleExportSchema = z.object({
+    name: z.string(),
+    status: z.enum(["packing", "ready", "failed"]),
+    bytes: z.number(),
+    createdAt: z.number(),
+    secrets: z.boolean(),
+    error: z.string().optional(),
+});
+export const BundleExportsSchema = z.object({ exports: z.array(BundleExportSchema) });
 export const SecretSetSchema = z.object({
     key: z
         .string()
@@ -1321,18 +2091,35 @@ export const SecretInventoryEntrySchema = z.object({
     storedAt: z.string(),
     revealable: z.boolean(),
     ci: z.object({ synced: z.boolean(), pushedAt: z.string().optional() }).optional(),
+    lastUse: z.object({ at: z.number(), lane: z.enum(["shell", "code", "browser"]), detail: z.string().optional() }).optional(),
 });
 export const SecretInventorySchema = z.object({ entries: z.array(SecretInventoryEntrySchema) });
+export const AdapterHealthSchema = z.object({
+    state: z.enum(["ready", "unavailable", "unknown"]),
+    detail: z.string().optional(),
+    checkedAt: z.number(),
+});
 export const InfoSchema = z.object({
     name: z.string().optional(),
     image: z.string().optional(),
     version: z.string().optional(),
     latest: z.string().optional(),
     updateAvailable: z.boolean().optional(),
-});
+    runtimes: z.record(z.string(), AdapterHealthSchema).optional(),
+    channel: z.string().optional(),
+    previousImage: z.string().optional(),
+    updateNotes: z.array(z.string()).optional(),
+    moreUpdateNotes: z.number().optional(),
+    breakingNotes: z.array(z.string()).optional(),
+});
+export const ManifestProblemSchema = z.object({
+    kind: z.enum(["unreadable", "unknownKey", "invalidEntry"]),
+    detail: z.string(),
+    suggestion: z.string().optional(),
+});
+export const ManifestProblemReportSchema = z.object({ path: z.string(), problems: z.array(ManifestProblemSchema) });
+export const ManifestProblemsSchema = z.array(ManifestProblemReportSchema);
 export const DaemonSessionSchema = z.object({ token: z.string(), expiresAt: z.number(), email: z.string() });
-export const HostTunnelInputSchema = z.object({ hostName: z.string().min(1) });
-export const HostTunnelSchema = z.object({ hostname: z.string(), tunnelToken: z.string() });
 export const ActivityEventSchema = z.object({
     id: z.string(),
     at: z.number(),
@@ -1346,6 +2133,10 @@ export const ActivityEventSchema = z.object({
     method: z.string().optional(),
     endpoint: z.string().optional(),
     sessionId: z.string().optional(),
+    turnId: z.string().optional(),
+    conversationId: z.string().optional(),
+    title: z.string().optional(),
+    origin: AgentOriginSchema.optional(),
     automationIds: z.array(z.string()).optional(),
     outcome: z.enum(["ok", "error"]).optional(),
     error: z.string().optional(),
@@ -1360,7 +2151,7 @@ export const ActivityListSchema = z.object({ events: z.array(ActivityEventSchema
 export const ActivityConnectionSchema = z.object({
     capabilityId: z.string(),
     provider: z.string(),
-    gateway: z.enum(["ready", "connecting", "disconnected", "idle"]),
+    gateway: z.enum(["ready", "connecting", "pairing", "disconnected", "idle"]),
     lastError: z.string().optional(),
 });
 export const ActivityStatusSchema = z.object({
@@ -1384,8 +2175,13 @@ export const UsageTurnSchema = z.object({
     durationMs: z.number(),
     terse: z.boolean().optional(),
     iqContext: z.boolean().optional(),
-    iqContextNote: z.boolean().optional(),
+    iqContextOutcome: IqContextOutcomeSchema.optional(),
+    iqSearchArm: z.boolean().optional(),
+    iqSearchCohort: z.string().optional(),
+    iqContextDurationMs: z.number().nonnegative().optional(),
     proseChars: z.number().optional(),
+    searchCalls: z.number().optional(),
+    openingSearches: z.number().optional(),
 });
 export const UsageRollupRowSchema = z.object({
     day: z.string(),
@@ -1434,29 +2230,6 @@ export const LogReadSchema = z.object({
     text: z.string(),
     truncated: z.boolean(),
 });
-export const MemoryFileEntrySchema = z.object({
-    project: z.string(),
-    name: z.string(),
-    sizeBytes: z.number(),
-    modifiedAt: z.number(),
-});
-export const MemoryListSchema = z.object({ files: z.array(MemoryFileEntrySchema) });
-export const MemoryFileQuerySchema = z.object({
-    project: z.string().min(1),
-    name: z.string().min(1),
-});
-export const MemoryFileSchema = z.object({
-    project: z.string(),
-    name: z.string(),
-    content: z.string(),
-    sizeBytes: z.number(),
-    modifiedAt: z.number(),
-});
-export const MemoryWriteSchema = z.object({
-    project: z.string().min(1),
-    name: z.string().min(1),
-    content: z.string().max(1_048_576),
-});
 export const PresenceReportSchema = z.object({
     clientId: z.string(),
     idle: z.boolean(),
@@ -1465,7 +2238,7 @@ export const PresenceReportSchema = z.object({
     path: z.string().optional(),
 });
 export const PushSubscriptionSchema = z.object({
-    endpoint: z.string().url(),
+    endpoint: z.url(),
     keys: z.object({
         p256dh: z.string().min(1),
         auth: z.string().min(1),
@@ -1479,10 +2252,10 @@ export const PushNotificationSchema = z.object({
     requireInteraction: z.boolean().optional(),
 });
 export const PushConfigSchema = z.object({ publicKey: z.string(), subscribed: z.boolean() });
-export const PushEndpointSchema = z.object({ endpoint: z.string().url() });
-export const PushConfigQuerySchema = z.object({ endpoint: z.string().url().optional() });
+export const PushEndpointSchema = z.object({ endpoint: z.url() });
+export const PushConfigQuerySchema = z.object({ endpoint: z.url().optional() });
 export const PushTestSchema = z.object({ delivered: z.number().int().nonnegative() });
-export const PROBE_IDS = ["outdated", "audit", "knip", "jscpd"];
+export const PROBE_IDS = ["outdated", "audit", "knip", "jscpd", "ui", "bundle"];
 export const ProbeIdSchema = z.enum(PROBE_IDS);
 export const OutdatedPackageSchema = z.object({
     name: z.string(),
@@ -1511,12 +2284,25 @@ export const DuplicationSchema = z.object({
     clones: z.number().int().nonnegative(),
     top: z.array(z.object({ lines: z.number().int().nonnegative(), first: z.string(), second: z.string() })),
 });
+export const UiScanSchema = z.object({
+    components: z.array(z.string()),
+    bypasses: z.array(z.object({ path: z.string(), count: z.number().int().positive() })),
+    idioms: z.array(z.object({ id: z.string(), files: z.array(z.string()) })),
+});
+export const BundleSchema = z.object({
+    dir: z.string(),
+    totalBytes: z.number().int().nonnegative(),
+    totalGzip: z.number().int().nonnegative(),
+    assets: z.array(z.object({ path: z.string(), bytes: z.number().int().nonnegative(), gzip: z.number().int().nonnegative() })),
+});
 export const ProbeStateSchema = z.enum(["ok", "unavailable", "failed"]);
 export const ProbeFactsSchema = z.discriminatedUnion("id", [
     z.object({ id: z.literal("outdated"), packages: z.array(OutdatedPackageSchema) }),
     z.object({ id: z.literal("audit"), advisories: z.array(AdvisorySchema) }),
     z.object({ id: z.literal("knip"), deadCode: DeadCodeSchema }),
     z.object({ id: z.literal("jscpd"), duplication: DuplicationSchema }),
+    z.object({ id: z.literal("ui"), scan: UiScanSchema }),
+    z.object({ id: z.literal("bundle"), bundle: BundleSchema }),
 ]);
 export const ProbeResultSchema = z.object({
     id: ProbeIdSchema,
@@ -1540,6 +2326,7 @@ export const ChoreShapeSchema = z.object({
     ci: z.array(z.string()),
     lockfile: z.boolean(),
     packageManifest: z.boolean(),
+    deps: z.array(z.string()),
 });
 export const ChoreSignalsSchema = z.object({
     packages: z.array(ChorePackageSchema),
@@ -1559,11 +2346,25 @@ export const ChoreLedgerEntrySchema = z.object({
     digest: z.string(),
     snoozedUntil: z.number().optional(),
 });
+export const RunningProbeSchema = z.object({
+    repo: z.string(),
+    id: ProbeIdSchema,
+    askedAt: z.number(),
+    startedAt: z.number().optional(),
+});
 export const ChoresReportSchema = z.object({
     repos: z.array(z.object({ repo: z.string(), probes: z.array(ProbeResultSchema), signals: ChoreSignalsSchema })),
     ledger: z.array(ChoreLedgerEntrySchema),
+    running: z.array(RunningProbeSchema),
     node: z.string(),
 });
 export const ChoreProbeRequestSchema = z.object({ repo: z.string().min(1), id: ProbeIdSchema });
 export const ChoreLedgerWriteSchema = ChoreLedgerEntrySchema;
+export const ReadinessCheckSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    status: z.enum(["pass", "warn", "fail"]),
+    detail: z.string(),
+});
+export const ExtensionReadinessSchema = z.object({ checks: z.array(ReadinessCheckSchema) });
 //# sourceMappingURL=schemas.js.map