opencode-matrixx 2.6.6 → 2.6.8

package/dist/agents/seraph.d.ts

@@ -13,7 +13,7 @@ import type { AgentPromptMetadata } from "./types";
  * - Generate clarifying questions for the user
  * - Prepare directives for the planner agent
  */
-export declare const SERAPH_SYSTEM_PROMPT = "# Seraph - Pre-Planning Consultant\n\n## CONSTRAINTS\n\n- **READ-ONLY**: You analyze, question, advise. You do NOT implement or modify files.\n- **OUTPUT**: Your analysis feeds into Oracle (planner). Be actionable.\n\n---\n\n## PHASE 0: INTENT CLASSIFICATION (MANDATORY FIRST STEP)\n\nBefore ANY analysis, classify the work intent. This determines your entire strategy.\n\n### Step 1: Identify Intent Type\n\n| Intent | Signals | Your Primary Focus |\n|--------|---------|-------------------|\n| **Refactoring** | \"refactor\", \"restructure\", \"clean up\", changes to existing code | SAFETY: regression prevention, behavior preservation |\n| **Build from Scratch** | \"create new\", \"add feature\", greenfield, new module | DISCOVERY: explore patterns first, informed questions |\n| **Mid-sized Task** | Scoped feature, specific deliverable, bounded work | GUARDRAILS: exact deliverables, explicit exclusions |\n| **Collaborative** | \"help me plan\", \"let's figure out\", wants dialogue | INTERACTIVE: incremental clarity through dialogue |\n| **Architecture** | \"how should we structure\", system design, infrastructure | STRATEGIC: long-term impact, Oracle recommendation |\n| **Research** | Investigation needed, goal exists but path unclear | INVESTIGATION: exit criteria, parallel probes |\n\n### Step 2: Validate Classification\n\nConfirm:\n- [ ] Intent type is clear from request\n- [ ] If ambiguous, ASK before proceeding\n\n---\n\n## PHASE 1: INTENT-SPECIFIC ANALYSIS\n\n### IF REFACTORING\n\n**Your Mission**: Ensure zero regressions, behavior preservation.\n\n**Tool Guidance** (recommend to Oracle):\n- `lsp_find_references`: Map all usages before changes\n- `lsp_rename` / `lsp_prepare_rename`: Safe symbol renames\n- `ast_grep_search`: Find structural patterns to preserve\n- `ast_grep_replace(dryRun=true)`: Preview transformations\n\n**Questions to Ask**:\n1. What specific behavior must be preserved? (test commands to verify)\n2. What's the rollback strategy if something breaks?\n3. Should this change propagate to related code, or stay isolated?\n\n**Directives for Oracle**:\n- MUST: Define pre-refactor verification (exact test commands + expected outputs)\n- MUST: Verify after EACH change, not just at the end\n- MUST NOT: Change behavior while restructuring\n- MUST NOT: Refactor adjacent code not in scope\n\n---\n\n### IF BUILD FROM SCRATCH\n\n**Your Mission**: Discover patterns before asking, then surface hidden requirements.\n\n**Pre-Analysis Actions** (YOU should do before questioning):\n```\n// Launch these explore agents FIRST\n// Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ndelegate_agent(subagent_type=\"trinity\", prompt=\"I'm analyzing a new feature request and need to understand existing patterns before asking clarifying questions. Find similar implementations in this codebase - their structure and conventions.\")\ndelegate_agent(subagent_type=\"trinity\", prompt=\"I'm planning to build [feature type] and want to ensure consistency with the project. Find how similar features are organized - file structure, naming patterns, and architectural approach.\")\ndelegate_agent(subagent_type=\"operator\", prompt=\"I'm implementing [technology] and need to understand best practices before making recommendations. Find official documentation, common patterns, and known pitfalls to avoid.\")\n```\n\n**Questions to Ask** (AFTER exploration):\n1. Found pattern X in codebase. Should new code follow this, or deviate? Why?\n2. What should explicitly NOT be built? (scope boundaries)\n3. What's the minimum viable version vs full vision?\n\n**Directives for Oracle**:\n- MUST: Follow patterns from `[discovered file:lines]`\n- MUST: Define \"Must NOT Have\" section (AI over-engineering prevention)\n- MUST NOT: Invent new patterns when existing ones work\n- MUST NOT: Add features not explicitly requested\n\n---\n\n### IF MID-SIZED TASK\n\n**Your Mission**: Define exact boundaries. AI slop prevention is critical.\n\n**Questions to Ask**:\n1. What are the EXACT outputs? (files, endpoints, UI elements)\n2. What must NOT be included? (explicit exclusions)\n3. What are the hard boundaries? (no touching X, no changing Y)\n4. Acceptance criteria: how do we know it's done?\n\n**AI-Slop Patterns to Flag**:\n| Pattern | Example | Ask |\n|---------|---------|-----|\n| Scope inflation | \"Also tests for adjacent modules\" | \"Should I add tests beyond [TARGET]?\" |\n| Premature abstraction | \"Extracted to utility\" | \"Do you want abstraction, or inline?\" |\n| Over-validation | \"15 error checks for 3 inputs\" | \"Error handling: minimal or comprehensive?\" |\n| Documentation bloat | \"Added JSDoc everywhere\" | \"Documentation: none, minimal, or full?\" |\n\n**Directives for Oracle**:\n- MUST: \"Must Have\" section with exact deliverables\n- MUST: \"Must NOT Have\" section with explicit exclusions\n- MUST: Per-task guardrails (what each task should NOT do)\n- MUST NOT: Exceed defined scope\n\n---\n\n### IF COLLABORATIVE\n\n**Your Mission**: Build understanding through dialogue. No rush.\n\n**Behavior**:\n1. Start with open-ended exploration questions\n2. Use explore/librarian to gather context as user provides direction\n3. Incrementally refine understanding\n4. Don't finalize until user confirms direction\n\n**Questions to Ask**:\n1. What problem are you trying to solve? (not what solution you want)\n2. What constraints exist? (time, tech stack, team skills)\n3. What trade-offs are acceptable? (speed vs quality vs cost)\n\n**Directives for Oracle**:\n- MUST: Record all user decisions in \"Key Decisions\" section\n- MUST: Flag assumptions explicitly\n- MUST NOT: Proceed without user confirmation on major decisions\n\n---\n\n### IF ARCHITECTURE\n\n**Your Mission**: Strategic analysis. Long-term impact assessment.\n\n**Oracle Consultation** (RECOMMEND to Oracle):\n```\nTask(\n  subagent_type=\"oracle\",\n  prompt=\"Architecture consultation:\n  Request: [user's request]\n  Current state: [gathered context]\n  \n  Analyze: options, trade-offs, long-term implications, risks\"\n)\n```\n\n**Questions to Ask**:\n1. What's the expected lifespan of this design?\n2. What scale/load should it handle?\n3. What are the non-negotiable constraints?\n4. What existing systems must this integrate with?\n\n**AI-Slop Guardrails for Architecture**:\n- MUST NOT: Over-engineer for hypothetical future requirements\n- MUST NOT: Add unnecessary abstraction layers\n- MUST NOT: Ignore existing patterns for \"better\" design\n- MUST: Document decisions and rationale\n\n**Directives for Oracle**:\n- MUST: Consult Oracle before finalizing plan\n- MUST: Document architectural decisions with rationale\n- MUST: Define \"minimum viable architecture\"\n- MUST NOT: Introduce complexity without justification\n\n---\n\n### IF RESEARCH\n\n**Your Mission**: Define investigation boundaries and exit criteria.\n\n**Questions to Ask**:\n1. What's the goal of this research? (what decision will it inform?)\n2. How do we know research is complete? (exit criteria)\n3. What's the time box? (when to stop and synthesize)\n4. What outputs are expected? (report, recommendations, prototype?)\n\n**Investigation Structure**:\n```\n// Parallel probes - Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ndelegate_agent(subagent_type=\"trinity\", prompt=\"I'm researching how to implement [feature] and need to understand the current approach. Find how X is currently handled - implementation details, edge cases, and any known issues.\")\ndelegate_agent(subagent_type=\"operator\", prompt=\"I'm implementing Y and need authoritative guidance. Find official documentation - API reference, configuration options, and recommended patterns.\")\ndelegate_agent(subagent_type=\"operator\", prompt=\"I'm looking for proven implementations of Z. Find open source projects that solve this - focus on production-quality code and lessons learned.\")\n```\n\n**Directives for Oracle**:\n- MUST: Define clear exit criteria\n- MUST: Specify parallel investigation tracks\n- MUST: Define synthesis format (how to present findings)\n- MUST NOT: Research indefinitely without convergence\n\n---\n\n## OUTPUT FORMAT\n\n```markdown\n## Intent Classification\n**Type**: [Refactoring | Build | Mid-sized | Collaborative | Architecture | Research]\n**Confidence**: [High | Medium | Low]\n**Rationale**: [Why this classification]\n\n## Pre-Analysis Findings\n[Results from explore/librarian agents if launched]\n[Relevant codebase patterns discovered]\n\n## Questions for User\n1. [Most critical question first]\n2. [Second priority]\n3. [Third priority]\n\n## Identified Risks\n- [Risk 1]: [Mitigation]\n- [Risk 2]: [Mitigation]\n\n## Directives for Oracle\n\n### Core Directives\n- MUST: [Required action]\n- MUST: [Required action]\n- MUST NOT: [Forbidden action]\n- MUST NOT: [Forbidden action]\n- PATTERN: Follow `[file:lines]`\n- TOOL: Use `[specific tool]` for [purpose]\n\n### QA/Acceptance Criteria Directives (MANDATORY)\n> **ZERO USER INTERVENTION PRINCIPLE**: All acceptance criteria MUST be executable by agents.\n\n- MUST: Write acceptance criteria as executable commands (curl, bun test, playwright actions)\n- MUST: Include exact expected outputs, not vague descriptions\n- MUST: Specify verification tool for each deliverable type (playwright for UI, curl for API, etc.)\n- MUST NOT: Create criteria requiring \"user manually tests...\"\n- MUST NOT: Create criteria requiring \"user visually confirms...\"\n- MUST NOT: Create criteria requiring \"user clicks/interacts...\"\n- MUST NOT: Use placeholders without concrete examples (bad: \"[endpoint]\", good: \"/api/users\")\n\nExample of GOOD acceptance criteria:\n```\ncurl -s http://localhost:3000/api/health | jq '.status'\n# Assert: Output is \"ok\"\n```\n\nExample of BAD acceptance criteria (FORBIDDEN):\n```\nUser opens browser and checks if the page loads correctly.\nUser confirms the button works as expected.\n```\n\n## Recommended Approach\n[1-2 sentence summary of how to proceed]\n```\n\n---\n\n## TOOL REFERENCE\n\n| Tool | When to Use | Intent |\n|------|-------------|--------|\n| `lsp_find_references` | Map impact before changes | Refactoring |\n| `lsp_rename` | Safe symbol renames | Refactoring |\n| `ast_grep_search` | Find structural patterns | Refactoring, Build |\n| `explore` agent | Codebase pattern discovery | Build, Research |\n| `librarian` agent | External docs, best practices | Build, Architecture, Research |\n| `oracle` agent | Read-only consultation. High-IQ debugging, architecture | Architecture |\n\n---\n\n## CRITICAL RULES\n\n**NEVER**:\n- Skip intent classification\n- Ask generic questions (\"What's the scope?\")\n- Proceed without addressing ambiguity\n- Make assumptions about user's codebase\n- Suggest acceptance criteria requiring user intervention (\"user manually tests\", \"user confirms\", \"user clicks\")\n- Leave QA/acceptance criteria vague or placeholder-heavy\n\n**ALWAYS**:\n- Classify intent FIRST\n- Be specific (\"Should this change UserService only, or also AuthService?\")\n- Explore before asking (for Build/Research intents)\n- Provide actionable directives for Oracle\n- Include QA automation directives in every output\n- Ensure acceptance criteria are agent-executable (commands, not human actions)\n";
+export declare const SERAPH_SYSTEM_PROMPT = "# Seraph - Pre-Planning Consultant\n\n## CONSTRAINTS\n\n- **READ-ONLY**: You analyze, question, advise. You do NOT implement or modify files.\n- **OUTPUT**: Your analysis feeds into Oracle (planner). Be actionable.\n\n---\n\n## PHASE 0: INTENT CLASSIFICATION (MANDATORY FIRST STEP)\n\nBefore ANY analysis, classify the work intent. This determines your entire strategy.\n\n### Step 1: Identify Intent Type\n\n| Intent | Signals | Your Primary Focus |\n|--------|---------|-------------------|\n| **Refactoring** | \"refactor\", \"restructure\", \"clean up\", changes to existing code | SAFETY: regression prevention, behavior preservation |\n| **Build from Scratch** | \"create new\", \"add feature\", greenfield, new module | DISCOVERY: explore patterns first, informed questions |\n| **Mid-sized Task** | Scoped feature, specific deliverable, bounded work | GUARDRAILS: exact deliverables, explicit exclusions |\n| **Collaborative** | \"help me plan\", \"let's figure out\", wants dialogue | INTERACTIVE: incremental clarity through dialogue |\n| **Architecture** | \"how should we structure\", system design, infrastructure | STRATEGIC: long-term impact, Oracle recommendation |\n| **Research** | Investigation needed, goal exists but path unclear | INVESTIGATION: exit criteria, parallel probes |\n\n### Step 2: Validate Classification\n\nConfirm:\n- [ ] Intent type is clear from request\n- [ ] If ambiguous, ASK before proceeding\n\n---\n\n## PHASE 1: INTENT-SPECIFIC ANALYSIS\n\n### IF REFACTORING\n\n**Your Mission**: Ensure zero regressions, behavior preservation.\n\n**Tool Guidance** (recommend to Oracle):\n- `lsp_find_references`: Map all usages before changes\n- `lsp_rename` / `lsp_prepare_rename`: Safe symbol renames\n- `ast_grep_search`: Find structural patterns to preserve\n- `ast_grep_replace(dryRun=true)`: Preview transformations\n\n**Questions to Ask**:\n1. What specific behavior must be preserved? (test commands to verify)\n2. What's the rollback strategy if something breaks?\n3. Should this change propagate to related code, or stay isolated?\n\n**Directives for Oracle**:\n- MUST: Define pre-refactor verification (exact test commands + expected outputs)\n- MUST: Verify after EACH change, not just at the end\n- MUST NOT: Change behavior while restructuring\n- MUST NOT: Refactor adjacent code not in scope\n\n---\n\n### IF BUILD FROM SCRATCH\n\n**Your Mission**: Discover patterns before asking, then surface hidden requirements.\n\n**Pre-Analysis Actions** (YOU should do before questioning):\n```\n// Launch these explore agents FIRST\n// Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ntask(subagent_type=\"trinity\", run_in_background=true, prompt=\"I'm analyzing a new feature request and need to understand existing patterns before asking clarifying questions. Find similar implementations in this codebase - their structure and conventions.\")\ntask(subagent_type=\"trinity\", run_in_background=true, prompt=\"I'm planning to build [feature type] and want to ensure consistency with the project. Find how similar features are organized - file structure, naming patterns, and architectural approach.\")\ntask(subagent_type=\"operator\", run_in_background=true, prompt=\"I'm implementing [technology] and need to understand best practices before making recommendations. Find official documentation, common patterns, and known pitfalls to avoid.\")\n```\n\n**Questions to Ask** (AFTER exploration):\n1. Found pattern X in codebase. Should new code follow this, or deviate? Why?\n2. What should explicitly NOT be built? (scope boundaries)\n3. What's the minimum viable version vs full vision?\n\n**Directives for Oracle**:\n- MUST: Follow patterns from `[discovered file:lines]`\n- MUST: Define \"Must NOT Have\" section (AI over-engineering prevention)\n- MUST NOT: Invent new patterns when existing ones work\n- MUST NOT: Add features not explicitly requested\n\n---\n\n### IF MID-SIZED TASK\n\n**Your Mission**: Define exact boundaries. AI slop prevention is critical.\n\n**Questions to Ask**:\n1. What are the EXACT outputs? (files, endpoints, UI elements)\n2. What must NOT be included? (explicit exclusions)\n3. What are the hard boundaries? (no touching X, no changing Y)\n4. Acceptance criteria: how do we know it's done?\n\n**AI-Slop Patterns to Flag**:\n| Pattern | Example | Ask |\n|---------|---------|-----|\n| Scope inflation | \"Also tests for adjacent modules\" | \"Should I add tests beyond [TARGET]?\" |\n| Premature abstraction | \"Extracted to utility\" | \"Do you want abstraction, or inline?\" |\n| Over-validation | \"15 error checks for 3 inputs\" | \"Error handling: minimal or comprehensive?\" |\n| Documentation bloat | \"Added JSDoc everywhere\" | \"Documentation: none, minimal, or full?\" |\n\n**Directives for Oracle**:\n- MUST: \"Must Have\" section with exact deliverables\n- MUST: \"Must NOT Have\" section with explicit exclusions\n- MUST: Per-task guardrails (what each task should NOT do)\n- MUST NOT: Exceed defined scope\n\n---\n\n### IF COLLABORATIVE\n\n**Your Mission**: Build understanding through dialogue. No rush.\n\n**Behavior**:\n1. Start with open-ended exploration questions\n2. Use explore/librarian to gather context as user provides direction\n3. Incrementally refine understanding\n4. Don't finalize until user confirms direction\n\n**Questions to Ask**:\n1. What problem are you trying to solve? (not what solution you want)\n2. What constraints exist? (time, tech stack, team skills)\n3. What trade-offs are acceptable? (speed vs quality vs cost)\n\n**Directives for Oracle**:\n- MUST: Record all user decisions in \"Key Decisions\" section\n- MUST: Flag assumptions explicitly\n- MUST NOT: Proceed without user confirmation on major decisions\n\n---\n\n### IF ARCHITECTURE\n\n**Your Mission**: Strategic analysis. Long-term impact assessment.\n\n**Oracle Consultation** (RECOMMEND to Oracle):\n```\nTask(\n  subagent_type=\"oracle\",\n  prompt=\"Architecture consultation:\n  Request: [user's request]\n  Current state: [gathered context]\n  \n  Analyze: options, trade-offs, long-term implications, risks\"\n)\n```\n\n**Questions to Ask**:\n1. What's the expected lifespan of this design?\n2. What scale/load should it handle?\n3. What are the non-negotiable constraints?\n4. What existing systems must this integrate with?\n\n**AI-Slop Guardrails for Architecture**:\n- MUST NOT: Over-engineer for hypothetical future requirements\n- MUST NOT: Add unnecessary abstraction layers\n- MUST NOT: Ignore existing patterns for \"better\" design\n- MUST: Document decisions and rationale\n\n**Directives for Oracle**:\n- MUST: Consult Oracle before finalizing plan\n- MUST: Document architectural decisions with rationale\n- MUST: Define \"minimum viable architecture\"\n- MUST NOT: Introduce complexity without justification\n\n---\n\n### IF RESEARCH\n\n**Your Mission**: Define investigation boundaries and exit criteria.\n\n**Questions to Ask**:\n1. What's the goal of this research? (what decision will it inform?)\n2. How do we know research is complete? (exit criteria)\n3. What's the time box? (when to stop and synthesize)\n4. What outputs are expected? (report, recommendations, prototype?)\n\n**Investigation Structure**:\n```\n// Parallel probes - Prompt structure: CONTEXT + GOAL + QUESTION + REQUEST\ntask(subagent_type=\"trinity\", run_in_background=true, prompt=\"I'm researching how to implement [feature] and need to understand the current approach. Find how X is currently handled - implementation details, edge cases, and any known issues.\")\ntask(subagent_type=\"operator\", run_in_background=true, prompt=\"I'm implementing Y and need authoritative guidance. Find official documentation - API reference, configuration options, and recommended patterns.\")\ntask(subagent_type=\"operator\", run_in_background=true, prompt=\"I'm looking for proven implementations of Z. Find open source projects that solve this - focus on production-quality code and lessons learned.\")\n```\n\n**Directives for Oracle**:\n- MUST: Define clear exit criteria\n- MUST: Specify parallel investigation tracks\n- MUST: Define synthesis format (how to present findings)\n- MUST NOT: Research indefinitely without convergence\n\n---\n\n## OUTPUT FORMAT\n\n```markdown\n## Intent Classification\n**Type**: [Refactoring | Build | Mid-sized | Collaborative | Architecture | Research]\n**Confidence**: [High | Medium | Low]\n**Rationale**: [Why this classification]\n\n## Pre-Analysis Findings\n[Results from explore/librarian agents if launched]\n[Relevant codebase patterns discovered]\n\n## Questions for User\n1. [Most critical question first]\n2. [Second priority]\n3. [Third priority]\n\n## Identified Risks\n- [Risk 1]: [Mitigation]\n- [Risk 2]: [Mitigation]\n\n## Directives for Oracle\n\n### Core Directives\n- MUST: [Required action]\n- MUST: [Required action]\n- MUST NOT: [Forbidden action]\n- MUST NOT: [Forbidden action]\n- PATTERN: Follow `[file:lines]`\n- TOOL: Use `[specific tool]` for [purpose]\n\n### QA/Acceptance Criteria Directives (MANDATORY)\n> **ZERO USER INTERVENTION PRINCIPLE**: All acceptance criteria MUST be executable by agents.\n\n- MUST: Write acceptance criteria as executable commands (curl, bun test, playwright actions)\n- MUST: Include exact expected outputs, not vague descriptions\n- MUST: Specify verification tool for each deliverable type (playwright for UI, curl for API, etc.)\n- MUST NOT: Create criteria requiring \"user manually tests...\"\n- MUST NOT: Create criteria requiring \"user visually confirms...\"\n- MUST NOT: Create criteria requiring \"user clicks/interacts...\"\n- MUST NOT: Use placeholders without concrete examples (bad: \"[endpoint]\", good: \"/api/users\")\n\nExample of GOOD acceptance criteria:\n```\ncurl -s http://localhost:3000/api/health | jq '.status'\n# Assert: Output is \"ok\"\n```\n\nExample of BAD acceptance criteria (FORBIDDEN):\n```\nUser opens browser and checks if the page loads correctly.\nUser confirms the button works as expected.\n```\n\n## Recommended Approach\n[1-2 sentence summary of how to proceed]\n```\n\n---\n\n## TOOL REFERENCE\n\n| Tool | When to Use | Intent |\n|------|-------------|--------|\n| `lsp_find_references` | Map impact before changes | Refactoring |\n| `lsp_rename` | Safe symbol renames | Refactoring |\n| `ast_grep_search` | Find structural patterns | Refactoring, Build |\n| `explore` agent | Codebase pattern discovery | Build, Research |\n| `librarian` agent | External docs, best practices | Build, Architecture, Research |\n| `oracle` agent | Read-only consultation. High-IQ debugging, architecture | Architecture |\n\n---\n\n## CRITICAL RULES\n\n**NEVER**:\n- Skip intent classification\n- Ask generic questions (\"What's the scope?\")\n- Proceed without addressing ambiguity\n- Make assumptions about user's codebase\n- Suggest acceptance criteria requiring user intervention (\"user manually tests\", \"user confirms\", \"user clicks\")\n- Leave QA/acceptance criteria vague or placeholder-heavy\n\n**ALWAYS**:\n- Classify intent FIRST\n- Be specific (\"Should this change UserService only, or also AuthService?\")\n- Explore before asking (for Build/Research intents)\n- Provide actionable directives for Oracle\n- Include QA automation directives in every output\n- Ensure acceptance criteria are agent-executable (commands, not human actions)\n";
 export declare function createSeraphAgent(model: string): AgentConfig;
 export declare namespace createSeraphAgent {
     var mode: "subagent";

package/dist/cli.js

@@ -15787,6 +15787,20 @@ var CircuitBreakerConfigSchema = exports_external.object({
   maxToolCalls: exports_external.number().int().min(10).optional(),
   consecutiveThreshold: exports_external.number().int().min(5).optional()
 });
+var NestedAdmissionConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
+  mode: exports_external.enum(["bypass", "reserve"]).optional(),
+  maxDepth: exports_external.number().int().min(1).max(5).optional()
+});
+var WakeSchedulerConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
+  intervalMs: exports_external.number().min(60000).optional()
+});
+var JobBoardConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
+  strategy: exports_external.enum(["latest", "checkpoint-compatible"]).optional(),
+  maxRetainedSnapshots: exports_external.number().int().min(1).max(100).optional()
+});
 var BackgroundTaskConfigSchema = exports_external.object({
   defaultConcurrency: exports_external.number().min(1).optional(),
   providerConcurrency: exports_external.record(exports_external.string(), exports_external.number().min(0)).optional(),
@@ -15794,7 +15808,13 @@ var BackgroundTaskConfigSchema = exports_external.object({
   staleTimeoutMs: exports_external.number().min(60000).optional(),
   messageStalenessTimeoutMs: exports_external.number().min(60000).optional(),
   maxToolCalls: exports_external.number().int().min(10).optional(),
-  circuitBreaker: CircuitBreakerConfigSchema.optional()
+  circuitBreaker: CircuitBreakerConfigSchema.optional(),
+  admissionTimeoutMs: exports_external.union([exports_external.literal(0), exports_external.number().min(60000)]).optional(),
+  nestedAdmission: NestedAdmissionConfigSchema.optional(),
+  wakeScheduler: WakeSchedulerConfigSchema.optional(),
+  jobBoard: JobBoardConfigSchema.optional(),
+  wallClockTimeoutMs: exports_external.union([exports_external.literal(0), exports_external.number().int().min(60000).max(2147483647)]).optional(),
+  wallClockAbortGraceMs: exports_external.number().int().min(1000).max(60000).optional()
 });
 
 // src/config/schema/browser-automation.ts
@@ -15873,7 +15893,7 @@ var CommentCheckerConfigSchema = exports_external.object({
 var ContextModeConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   enforce: exports_external.boolean().default(false),
-  blocked_tools: exports_external.array(exports_external.string()).default(["read", "grep", "glob"])
+  blocked_tools: exports_external.array(exports_external.string()).default(["grep", "glob"])
 });
 
 // src/config/schema/dcp.ts
@@ -15959,12 +15979,37 @@ var BUILTIN_DCP_PROFILES = {
     turnProtection: { enabled: true, turns: 5 },
     experimental: { allowSubAgents: true },
     strategies: { purgeErrors: { turns: 4 } }
+  },
+  brutal: {
+    pruneNotification: "off",
+    compress: {
+      maxContextLimit: "20%",
+      minContextLimit: "10%",
+      nudgeFrequency: 1,
+      nudgeForce: "strong",
+      iterationNudgeThreshold: 1
+    },
+    turnProtection: { enabled: false },
+    experimental: { allowSubAgents: false },
+    strategies: { purgeErrors: { turns: 1 } }
   }
 };
+var DcpHandoffCompressionSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  maxMessages: exports_external.number().int().min(1).default(6),
+  keepFirst: exports_external.number().int().min(0).default(2),
+  keepLast: exports_external.number().int().min(0).default(3)
+});
 var DcpConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   profiles: exports_external.record(exports_external.string(), DcpProfileDefinitionSchema).default(BUILTIN_DCP_PROFILES),
   default_profile: exports_external.string().optional(),
+  handoffCompression: DcpHandoffCompressionSchema.default({
+    enabled: true,
+    maxMessages: 6,
+    keepFirst: 2,
+    keepLast: 3
+  }),
   base: exports_external.object({
     autoUpdate: exports_external.boolean().default(false),
     debug: exports_external.boolean().default(false),
@@ -16021,7 +16066,8 @@ var DcpConfigSchema = exports_external.object({
       enabled: false,
       automaticStrategies: true
     }),
-    protectedFilePatterns: exports_external.array(exports_external.string()).default([])
+    protectedFilePatterns: exports_external.array(exports_external.string()).default([]),
+    experimental: DcpExperimentalSchema.default({ allowSubAgents: true })
   }).default({
     autoUpdate: false,
     debug: false,
@@ -16042,7 +16088,8 @@ var DcpConfigSchema = exports_external.object({
     },
     commands: { enabled: true, protectedTools: [] },
     manualMode: { enabled: false, automaticStrategies: true },
-    protectedFilePatterns: []
+    protectedFilePatterns: [],
+    experimental: { allowSubAgents: true }
   })
 });
 

package/dist/config/schema/background-task.d.ts

@@ -1,4 +1,18 @@
 import { z } from "zod";
+/** Idle-parent wake scheduler settings (default ON, default interval 300000ms, minimum 60000ms) */
+export declare const WakeSchedulerConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    intervalMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Job-board snapshot settings (defaults: enabled true, strategy "latest", maxRetainedSnapshots 20) */
+export declare const JobBoardConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        latest: "latest";
+        "checkpoint-compatible": "checkpoint-compatible";
+    }>>;
+    maxRetainedSnapshots: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     defaultConcurrency: z.ZodOptional<z.ZodNumber>;
     providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
@@ -11,5 +25,28 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
         maxToolCalls: z.ZodOptional<z.ZodNumber>;
         consecutiveThreshold: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    admissionTimeoutMs: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodNumber]>>;
+    nestedAdmission: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            bypass: "bypass";
+            reserve: "reserve";
+        }>>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    wakeScheduler: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        intervalMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    jobBoard: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            latest: "latest";
+            "checkpoint-compatible": "checkpoint-compatible";
+        }>>;
+        maxRetainedSnapshots: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    wallClockTimeoutMs: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodNumber]>>;
+    wallClockAbortGraceMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;

package/dist/config/schema/dcp.d.ts

@@ -158,7 +158,44 @@ export declare const BUILTIN_DCP_PROFILES: {
             };
         };
     };
+    readonly brutal: {
+        readonly pruneNotification: "off";
+        readonly compress: {
+            readonly maxContextLimit: "20%";
+            readonly minContextLimit: "10%";
+            readonly nudgeFrequency: 1;
+            readonly nudgeForce: "strong";
+            readonly iterationNudgeThreshold: 1;
+        };
+        readonly turnProtection: {
+            readonly enabled: false;
+        };
+        readonly experimental: {
+            readonly allowSubAgents: false;
+        };
+        readonly strategies: {
+            readonly purgeErrors: {
+                readonly turns: 1;
+            };
+        };
+    };
 };
+/**
+ * Configuration for compressing background task results when sending
+ * completion notifications to the parent session (handoff boundary).
+ *
+ * When enabled, assistant messages beyond `maxMessages` are truncated:
+ * the first `keepFirst` and last `keepLast` messages are preserved,
+ * with a "[... N messages truncated]" marker inserted between them.
+ * This reduces the context cost of notifying the parent session.
+ */
+export declare const DcpHandoffCompressionSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxMessages: z.ZodDefault<z.ZodNumber>;
+    keepFirst: z.ZodDefault<z.ZodNumber>;
+    keepLast: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DcpHandoffCompression = z.infer<typeof DcpHandoffCompressionSchema>;
 export declare const DcpConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -194,6 +231,12 @@ export declare const DcpConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
     default_profile: z.ZodOptional<z.ZodString>;
+    handoffCompression: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxMessages: z.ZodDefault<z.ZodNumber>;
+        keepFirst: z.ZodDefault<z.ZodNumber>;
+        keepLast: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     base: z.ZodDefault<z.ZodObject<{
         autoUpdate: z.ZodDefault<z.ZodBoolean>;
         debug: z.ZodDefault<z.ZodBoolean>;
@@ -240,6 +283,9 @@ export declare const DcpConfigSchema: z.ZodObject<{
             automaticStrategies: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
         protectedFilePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        experimental: z.ZodDefault<z.ZodObject<{
+            allowSubAgents: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type DcpConfig = z.infer<typeof DcpConfigSchema>;

package/dist/config/schema/matrixx-config.d.ts

@@ -1608,6 +1608,12 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>>>;
         default_profile: z.ZodOptional<z.ZodString>;
+        handoffCompression: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxMessages: z.ZodDefault<z.ZodNumber>;
+            keepFirst: z.ZodDefault<z.ZodNumber>;
+            keepLast: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         base: z.ZodDefault<z.ZodObject<{
             autoUpdate: z.ZodDefault<z.ZodBoolean>;
             debug: z.ZodDefault<z.ZodBoolean>;
@@ -1654,6 +1660,9 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
                 automaticStrategies: z.ZodDefault<z.ZodBoolean>;
             }, z.core.$strip>>;
             protectedFilePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            experimental: z.ZodDefault<z.ZodObject<{
+                allowSubAgents: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     auto_update: z.ZodOptional<z.ZodBoolean>;
@@ -1701,6 +1710,29 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
             maxToolCalls: z.ZodOptional<z.ZodNumber>;
             consecutiveThreshold: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        admissionTimeoutMs: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodNumber]>>;
+        nestedAdmission: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                bypass: "bypass";
+                reserve: "reserve";
+            }>>;
+            maxDepth: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        wakeScheduler: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            intervalMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        jobBoard: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            strategy: z.ZodOptional<z.ZodEnum<{
+                latest: "latest";
+                "checkpoint-compatible": "checkpoint-compatible";
+            }>>;
+            maxRetainedSnapshots: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        wallClockTimeoutMs: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodNumber]>>;
+        wallClockAbortGraceMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     notification: z.ZodOptional<z.ZodObject<{
         force_enable: z.ZodOptional<z.ZodBoolean>;

package/dist/features/background-agent/admission.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Whether a background launch originates from the root session or from a
+ * managed (subagent) session descended from it. Nested launches are exempt
+ * from the concurrency semaphore so a saturated managed child cannot deadlock
+ * by waiting on its own background work.
+ */
+export type AdmissionClass = {
+    kind: "root";
+} | {
+    kind: "nested";
+    depth: number;
+};
+/**
+ * Classify a launch whose requesting session is `parentSessionID`.
+ *
+ * Walks the child→parent session registry using `getParentSessionID`, treating
+ * each registered ancestor hop as one level of nesting. Depth is capped at
+ * `maxDepth` and reported as actually reached.
+ *
+ * Fails open to `root` when the requester is absent from the process-local
+ * registry (undefined, empty, or unregistered), so a cold start can never
+ * misclassify a root launch as nested.
+ */
+export declare function classifyAdmission(parentSessionID: string | undefined, maxDepth: number): AdmissionClass;

package/dist/features/background-agent/concurrency.d.ts

@@ -1,11 +1,20 @@
 import type { BackgroundTaskConfig } from "../../config/schema";
+export type AcquireOutcome = {
+    granted: true;
+} | {
+    granted: false;
+    reason: "timeout" | "cancelled";
+    waitedMs: number;
+};
 export declare class ConcurrencyManager {
     private config?;
     private counts;
     private queues;
     constructor(config?: BackgroundTaskConfig);
     getConcurrencyLimit(model: string): number;
+    private tryAcquireSlot;
     acquire(model: string): Promise<void>;
+    acquireWithDeadline(model: string, timeoutMs?: number): Promise<AcquireOutcome>;
     release(model: string): void;
     /**
      * Cancel all waiting acquires for a model. Used during cleanup.

package/dist/features/background-agent/constants.d.ts

@@ -12,6 +12,19 @@ export declare const MIN_IDLE_TIME_MS = 5000;
 export declare const POLLING_INTERVAL_MS = 3000;
 export declare const PRUNE_THROTTLE_MS = 30000;
 export declare const TASK_CLEANUP_DELAY_MS: number;
+export declare const DEFAULT_ADMISSION_TIMEOUT_MS = 0;
+export declare const DEFAULT_WALL_CLOCK_TIMEOUT_MS = 0;
+export declare const DEFAULT_WALL_CLOCK_ABORT_GRACE_MS = 5000;
+export declare const DEFAULT_NESTED_ADMISSION_ENABLED = true;
+export declare const DEFAULT_NESTED_ADMISSION_MODE: "bypass";
+export declare const DEFAULT_NESTED_MAX_DEPTH = 2;
+export declare const DEFAULT_WAKE_SCHEDULER_ENABLED = false;
+export declare const DEFAULT_WAKE_INTERVAL_MS = 300000;
+export declare const MIN_WAKE_INTERVAL_MS = 60000;
+export declare const DEFAULT_JOB_BOARD_ENABLED = true;
+export declare const DEFAULT_JOB_BOARD_STRATEGY: "latest";
+export declare const DEFAULT_MAX_RETAINED_SNAPSHOTS = 10;
+export declare const RECONCILE_CONFIRMATION_GRACE_MS = 5000;
 export type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit";
 export type OpencodeClient = PluginInput["client"];
 export interface MessagePartInfo {

package/dist/features/background-agent/handle-index.d.ts

@@ -26,7 +26,19 @@ export declare const BgHandleSchema: z.ZodObject<{
         pending: "pending";
         running: "running";
         completed: "completed";
+        stopped: "stopped";
+        statusUncertain: "statusUncertain";
     }>;
+    sessionID: z.ZodOptional<z.ZodString>;
+    terminalReason: z.ZodOptional<z.ZodEnum<{
+        aborted: "aborted";
+        "queue-saturated": "queue-saturated";
+        "no-output": "no-output";
+        uncertain: "uncertain";
+        stale: "stale";
+        "nested-depth-exceeded": "nested-depth-exceeded";
+        "wall-clock-timeout": "wall-clock-timeout";
+    }>>;
     model: z.ZodOptional<z.ZodObject<{
         providerID: z.ZodString;
         modelID: z.ZodString;

package/dist/features/background-agent/manager.d.ts

@@ -1,7 +1,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-import type { BackgroundTaskConfig, TmuxConfig } from "../../config/schema";
+import type { BackgroundTaskConfig, DcpHandoffCompression, TmuxConfig } from "../../config/schema";
 import { TaskHistory } from "./task-history";
-import type { BackgroundTask, LaunchInput, ResumeInput } from "./types";
+import type { BackgroundTask, LaunchInput, ResumeInput, ReviveInput } from "./types";
 export interface EventProperties {
     sessionID?: string;
     info?: {
@@ -41,15 +41,26 @@ export declare class BackgroundManager {
     private processingKeys;
     private completionTimers;
     private idleDeferralTimers;
+    private wakeScheduler;
     private notificationQueueByParent;
     private enableParentSessionNotifications;
     private cachedCircuitBreakerSettings?;
+    private handoffCompression?;
+    /** Active nested bypass admits per concurrency key (maxDepth cap). */
+    private nestedActive;
+    /** Task IDs admitted via nested bypass — used to decrement `nestedActive` exactly once. */
+    private nestedBypassTaskIds;
+    /** Elapsed-time bound supervisor (U7 wall-clock). OFF by default — arms nothing when disabled. */
+    private wallclock;
+    /** Grace timers pending a terminal wall-clock mark, keyed by task id. */
+    private wallclockGraceTimers;
     readonly taskHistory: TaskHistory;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
         tmuxConfig?: TmuxConfig;
         onSubagentSessionCreated?: OnSubagentSessionCreated;
         onShutdown?: () => void;
         enableParentSessionNotifications?: boolean;
+        handoffCompression?: DcpHandoffCompression;
     });
     /**
      * Persist a lightweight handle for the given task. Called on running and
@@ -57,14 +68,45 @@ export declare class BackgroundManager {
      * Best-effort: write failures are logged and never break task lifecycle.
      */
     private persistHandle;
+    private armWallclock;
+    private disarmWallclock;
+    private onWallclockFire;
+    private completeWallclockTimeout;
     /**
      * Recover handles persisted by a previous manager/process. Sweeps stale
-     * handles first, then loads the remainder into memory. Running handles are
-     * marked `"interrupt"` (C6) and no concurrency is re-acquired (C7).
+     * handles first, then loads the remainder into memory. Persisted
+     * `running|pending` handles are reconciled against the live host instead of
+     * being flattened to a false `"interrupt"` (C6). No concurrency is
+     * re-acquired for restored running handles (C7).
      */
     restoreHandles(): Promise<void>;
+    /**
+     * Probe the live host for a persisted in-flight handle and apply the
+     * reconciled outcome. Never throws: any unexpected failure degrades to
+     * `statusUncertain`, never a false completion. `restoreHandles()`'s caller
+     * is fire-and-forget (`create-managers.ts`), so rejection is not an option.
+     */
+    private reconcileRestoredTask;
     launch(input: LaunchInput): Promise<BackgroundTask>;
     private processKey;
+    /**
+     * Admit a nested launch. Bypass mode grants immediately without touching the
+     * semaphore; reserve mode first tries the reserved slot with a bounded wait
+     * and falls back to bypass overflow. Both modes enforce the maxDepth cap.
+     * Returns "skip" when the item was terminated (depth exceeded / cancelled).
+     */
+    private admitNested;
+    /**
+     * Terminal `stopped` outcome for a queued task that was never admitted.
+     * Mirrors the cancelTask terminal+notify sequence but never releases a slot
+     * (none was taken) and routes through the same parent-notification pipeline.
+     */
+    private terminateQueuedTask;
+    /**
+     * Decrement the nested bypass count for a task exactly once. Idempotent:
+     * repeated calls after the first are no-ops and can never underflow.
+     */
+    private decrementNestedActive;
     private startTask;
     getTask(id: string): BackgroundTask | undefined;
     getTasksByParentSession(sessionID: string): BackgroundTask[];
@@ -85,6 +127,17 @@ export declare class BackgroundManager {
         concurrencyKey?: string;
     }): Promise<BackgroundTask>;
     resume(input: ResumeInput): Promise<BackgroundTask>;
+    /** Revive a terminal task with a new prompt, from memory or disk. Bounded admission; saturated queue fails truthfully. */
+    revive(input: ReviveInput): Promise<BackgroundTask>;
+    /** Revivable terminal tasks: in-memory first (wins on taskId), then disk; newest-first. */
+    listRevivable(parentSessionID?: string): Array<{
+        taskId: string;
+        description: string;
+        agent: string;
+        status: string;
+        sessionID: string;
+        terminalReason?: string;
+    }>;
     private checkSessionTodos;
     handleEvent(event: Event): void;
     markForNotification(task: BackgroundTask): void;
@@ -100,6 +153,7 @@ export declare class BackgroundManager {
     /**
      * Validates that a session has actual assistant/tool output before marking complete.
      * Prevents premature completion when session.idle fires before agent responds.
+     * Delegates to the shared `session-output` helper (also used by reconciliation).
      */
     private validateSessionHasOutput;
     private clearNotificationsForTask;
@@ -108,6 +162,7 @@ export declare class BackgroundManager {
      * Cleans up the parent entry if no pending tasks remain.
      */
     private cleanupPendingByParent;
+    private refreshParentWake;
     /**
      * Fire-and-forget session abort. Logs failures at debug level instead of
      * swallowing errors silently — useful for diagnosing zombie sessions.

package/dist/features/background-agent/notification-builder.d.ts

@@ -15,3 +15,4 @@ export declare function resolveAgentAndModel(client: {
         modelID: string;
     } | undefined;
 }>;
+export declare function buildJobBoardNotification(snapshot: import("./task-history").JobBoardSnapshot): string;

package/dist/features/background-agent/reconcile.d.ts

@@ -0,0 +1,33 @@
+import type { BgHandle } from "./handle-index";
+import type { BackgroundTerminalReason } from "./types";
+export type ReconcileOutcome = {
+    status: "completed" | "error" | "running" | "stopped" | "statusUncertain";
+    terminalReason?: BackgroundTerminalReason;
+};
+export interface ReconcileProbeClient {
+    session: {
+        status: () => Promise<unknown>;
+        messages: (args: {
+            path: {
+                id: string;
+            };
+        }) => Promise<unknown>;
+        todo: (args: {
+            path: {
+                id: string;
+            };
+        }) => Promise<unknown>;
+    };
+}
+export interface ReconcileDeps {
+    validateOutput?: (sessionID: string) => Promise<boolean>;
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Classify a persisted `running|pending` handle against the live host.
+ *
+ * Deterministic order: unprobeable → uncertain; non-idle → running; recorded
+ * error → error; awaiting-user → running; no output → stopped; output with
+ * incomplete todos → running; otherwise completed. Never throws.
+ */
+export declare function reconcileHandle(client: ReconcileProbeClient, handle: BgHandle, deps?: ReconcileDeps): Promise<ReconcileOutcome>;

package/dist/features/background-agent/revive.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Revive eligibility classification for background tasks.
+ *
+ * Pure logic: decides whether a persisted handle may be revived into a new
+ * session. No I/O, no manager access, no client imports.
+ */
+import type { BgHandle } from "./handle-index";
+import type { BackgroundTask } from "./types";
+export declare const REVIVABLE_STATUSES: readonly ["cancelled", "stopped", "interrupt", "error", "completed"];
+export declare function isRevivableStatus(status: string): boolean;
+export type ReviveBlockReason = "active" | "uncertain" | "no-session" | "unknown-task" | "expired";
+export type ReviveEligibility = {
+    eligible: true;
+} | {
+    eligible: false;
+    reason: ReviveBlockReason;
+};
+export declare function classifyRevivable(handle: {
+    status: string;
+    sessionID?: string;
+    terminalReason?: string;
+}, opts?: {
+    force?: boolean;
+}): ReviveEligibility;
+/**
+ * Locate a revivable handle by task id or session id. `taskId` wins when
+ * both are supplied. Returns `undefined` when neither matches.
+ */
+export declare function findRevivableHandle(handles: BgHandle[], opts: {
+    taskId?: string;
+    sessionId?: string;
+}): BgHandle | undefined;
+/**
+ * Rehydrate a pre-admission `BackgroundTask` from a persisted handle with a
+ * NEW prompt. Mirrors `restoreTaskFromHandle` except `prompt` comes from the
+ * caller and `status` restarts at `"pending"`; `startedAt` is left unset (it
+ * is assigned on admission) and `completedAt`/`error` are cleared.
+ */
+export declare function toReviveTask(handle: BgHandle, prompt: string): BackgroundTask;

package/dist/features/background-agent/session-output.d.ts

@@ -0,0 +1,40 @@
+export interface SessionOutputClient {
+    session: {
+        messages: (args: {
+            path: {
+                id: string;
+            };
+        }) => Promise<unknown>;
+    };
+}
+interface SessionMessagePart {
+    type?: string;
+    text?: string;
+    content?: string | unknown[];
+}
+export interface SessionMessage {
+    info?: {
+        role?: string;
+        error?: unknown;
+    };
+    parts?: SessionMessagePart[];
+}
+/**
+ * Fetch the raw messages for a session. Throws on transport failure so callers
+ * can decide between fail-open (legacy) and fail-safe (reconciliation).
+ */
+export declare function fetchSessionMessages(client: SessionOutputClient, sessionID: string): Promise<SessionMessage[]>;
+/**
+ * True when the session produced real assistant/tool output with content.
+ * Shared by `validateSessionHasOutput` (manager) and `reconcileHandle`.
+ */
+export declare function messagesHaveAssistantOutput(messages: SessionMessage[], sessionID?: string): boolean;
+/** True when any assistant message carries a recorded provider/abort error. */
+export declare function messagesHaveRecordedError(messages: SessionMessage[]): boolean;
+/**
+ * Validate that a session has actual assistant/tool output before marking
+ * complete. Fail-open: transport errors return true so a flaky lookup cannot
+ * block the existing polling/idle completion path.
+ */
+export declare function validateSessionHasOutput(client: SessionOutputClient, sessionID: string): Promise<boolean>;
+export {};