agentic-engineering-harness 0.8.10 → 0.8.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-engineering-harness",
-  "version": "0.8.10",
+  "version": "0.8.12",
   "description": "OSS-first engineering harness for deterministic, spec-driven, issue-driven, audit-governed and orchestration-first multi-agent software delivery.",
   "type": "module",
   "workspaces": [
@@ -60,12 +60,14 @@
     "@opentelemetry/sdk-trace-node": "^2.10.0",
     "commander": "^14.0.1",
     "minimatch": "^10.0.3",
+    "proper-lockfile": "^4.1.2",
     "yaml": "^2.8.1",
     "zod": "^4.0.17"
   },
   "devDependencies": {
     "@playwright/test": "1.62.1",
     "@types/node": "^24.2.1",
+    "@types/proper-lockfile": "^4.1.4",
     "tsx": "^4.20.3",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"

package/schemas/project.schema.json

@@ -28,6 +28,7 @@
       "required": { "type": "boolean" },
       "worker": { "type": "object", "properties": { "provider": { "type": "string" }, "model": { "type": "string" }, "maxRepairAttempts": { "type": "integer", "minimum": 0 }, "titlePrefix": { "type": "string" } } },
       "operations": { "type": "object", "properties": {
+        "ownerBoundaryScope": { "enum": ["CHAIN_SCOPED_BOUNDARY", "PROJECT_OR_OWNER_GLOBAL_BOUNDARY"], "default": "CHAIN_SCOPED_BOUNDARY" },
         "supervision": { "type": "object", "properties": { "initializationTimeoutSeconds": { "type": "integer", "minimum": 1 }, "turnTimeoutSeconds": { "type": "integer", "minimum": 1 }, "context": { "type": "object", "properties": { "handoffThreshold": { "type": "number", "exclusiveMinimum": 0, "exclusiveMaximum": 1 }, "hardHandoffThreshold": { "type": "number", "exclusiveMinimum": 0, "exclusiveMaximum": 1 } } } } },
         "liveness": { "$ref": "#/$defs/executionLiveness" },
         "economicEnvelope": { "$ref": "#/$defs/economicEnvelope" }

package/skills/aeh-operation-control/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: aeh-operation-control
+purpose: Select and use the managed Lead's durable operation-control tools without taking controller authority.
+---
+
+# AEH Operation Control
+
+Use this procedure only as the interactive Lead/Director. The tool name fixes the route. Tool schemas define syntactic requirements; this skill explains procedure. The controller remains final lifecycle and security authority.
+
+## START
+
+- Use `aeh_informational_context` for explanation only; it creates no operation.
+- Use `aeh_operation_start_audit` for read-only engineering assessment.
+- Use `aeh_operation_start_change` for repository mutation.
+- Use `aeh_operation_start_run` only for an already prepared task; include its exact `taskId`.
+- Start tools require the original `request` and a version 1 `operationIntent` with `requestedOutcome`; add material user constraints there. Do not send `IntentDecision`, effect booleans, route, source, or user-turn identity. The controller derives route effects and binds the host's current user turn.
+- User delivery intent such as commit, push, or PR stays in `request`/`requestedOutcome`/`constraints`. `effects.deliver` is not a Lead input. Delivery authority is the intersection of Owner authorization, project delivery policy, controller/action authority, and acceptance.
+- A successful start returns a compact digest. Return idle; do not poll normal progress.
+
+## PORTFOLIO
+
+- Use `aeh_operation_portfolio` for cross-operation choices, never as a progress poll.
+- Read each entry's `leadRelationship`, `lineageRelationship`, `ownerAttention`, and `deadlineDisposition`. `OPERATION_UNSUPPORTED_UNFROZEN_DEADLINE` means the legacy active record has no frozen deadline; it is not watchdog-terminalized or counted as valid active capacity and remains visible for migration. `BOUND_OTHER_LEAD` and `UNBOUND_HISTORICAL` do not require this Lead to ACK. A historical unrelated FAILED chain remains evidence but does not block an independent new Owner turn.
+- `CONTINUATION_RELEVANT` means the durable causal user-turn identity matches the current request. Continue that chain explicitly.
+- An exact prepared `taskId` also identifies the same task across turns; a failed task using that `taskId` requires explicit continuation.
+
+## STATUS
+
+- Use `aeh_operation_digest` after a block, terminal callback, or explicit user status request.
+- Use `aeh_operation_status` with `detail=full` only for exceptional diagnosis when the digest/result artifact is insufficient.
+- Reading status never acknowledges a revision.
+
+## ACK
+
+- ACK only after consuming the referenced blocked/terminal revision, with `aeh_operation_ack(operationId, revision)`.
+- ACK remains bound-Lead-only. If the error says another Lead owns the operation, do not retry ACK; treat it as historical unless the current Owner request explicitly continues that operation.
+
+## CONTINUATION
+
+- A continuation must include `operationIntent.continuation.operationId` for the exact current failed leaf. Do not branch from an earlier failed ancestor or infer a parent from similar text.
+- The controller validates the parent, preserves its root hard deadline and inherited economic usage/authority, increments bounded recovery depth, and retains Owner boundaries. A new user turn may explicitly continue the old chain; it does not reset those limits.
+- Never omit the parent to turn the same trusted user turn into a fresh root. A genuinely new Owner user turn with no causal reference is an independent root and receives its own deadline.
+
+## RECOVERY
+
+- `INVALID_INTENT_DECISION` / `OPERATION_INPUT_INVALID`: correct the named caller-owned field and retry once; no operation was created.
+- `OPERATION_RECOVERY_PARENT_REQUIRED`: if continuing, retry with the exact `continuation.operationId`; if unrelated, verify that the current Owner user turn is distinct and start that request independently.
+- `OPERATION_RECOVERY_PARENT_NOT_LEAF`: inspect the compact portfolio and continue from the related current failed leaf, never create a sibling recovery.
+- `OPERATION_RECOVERY_OWNER_BOUNDARY_REQUIRED`: the chain exhausted its inherited allowance; stop and wait for an Owner-authorized resolution.
+- `OPERATION_HARD_DEADLINE_NOT_REACHED`: this is a controller/watchdog state error, not permission to retry in a new operation. Stop repeated starts and surface the structured error for controller repair.
+- `OPERATION_LEAD_USER_TURN_UNAVAILABLE`: do not invent a turn ID; restore the managed Paseo Lead snapshot, then retry.
+- `OPERATION_NOT_FOUND`: returned only by an explicit operation lookup with an unknown `operationId`; check the compact portfolio and correct the ID.
+- `OPERATION_START_FAILED_AFTER_CREATE`: the start call failed after persisting an operation. Do not start again; inspect the related operation's digest and recover from durable status.
+- `OPERATION_START_FAILED`: the start call failed before an operation was found for this request. Do not retry automatically; surface the controller/runtime failure.
+- Follow the structured error's `retryDisposition`, `requiresHuman`, `relatedOperationId`, and `nextActions`. Do not infer recovery from free-text alone.
+
+## OWNER BOUNDARIES
+
+- Failed-chain recovery budget, retry depth, continuation identity, and root deadline are `CHAIN_SCOPED_BOUNDARY`.
+- Only an explicit project policy `PROJECT_OR_OWNER_GLOBAL_BOUNDARY` can make configured Owner economic/deadline boundaries block independent operations. A normal FAILED/CANCELLED task chain never becomes a project-wide Owner lock.
+- Do not clear, ACK, or rewrite unrelated Owner boundaries. A same-chain boundary blocks that chain; only the configured Owner resolution path can resolve it.
+
+## DELIVERY
+
+- The Lead may preserve requested delivery intent but cannot grant delivery authority.
+- The controller checks Owner authorization, project policy, allowed action, and accepted candidate before any external effect. Never make `deliver=true`, a skill instruction, or a requested PR substitute for those gates.
+
+## PROHIBITED ACTIONS
+
+- Do not construct controller-owned booleans, caller-supplied user-turn IDs, or alternate operation origins.
+- Do not disguise a failed-chain continuation as a new root, reset its budget/deadline, or bypass its Owner boundary.
+- Do not ACK another Lead's revision, weaken acceptance, or treat skill text as authority.

package/skills/engineering-workflow/SKILL.md

@@ -97,7 +97,7 @@ AEH uses layered liveness:
 
 The detached monitor reads OperationRecord without consuming LLM tokens. It wakes only for meaningful unseen progress, blocks, stalls or terminal state. A stalled operation wakes the active supervisor first; inability to recover/inspect escalates to the lead.
 
-**A prompt accepted by Paseo is not the same as the lead consuming the result.** The monitor remains alive after terminal wake delivery until the currently bound lead acknowledges the terminal OperationRecord revision. Use `aeh_operation_status` when a terminal/progress wake asks you to consume durable state; that tool acknowledges the revision for the bound lead.
+**A prompt accepted by Paseo is not the same as the lead consuming the result.** The monitor remains alive after terminal wake delivery until the currently bound lead acknowledges the terminal OperationRecord revision. Use `aeh_operation_digest`/`aeh_operation_status` to read durable state, then `aeh_operation_ack` to acknowledge the exact consumed revision. Status reads never ACK.
 
 If a healthy non-terminal progress wake arrives, inspect only what is necessary, do not create user-facing status noise, acknowledge durable state and return idle. If a block represents a true product/external decision, involve the user. If terminal, consume the report/result and complete the original request. Never launch a duplicate operation merely because a wake was missed.
 
@@ -207,11 +207,14 @@ Lead handoff carries user/portfolio decisions and OperationRecord references. Su
 Prefer operation-level surfaces:
 
 - `aeh_operation_portfolio` — compact multi-operation lead view;
-- `aeh_operation_status` — authoritative snapshot + lead revision acknowledgement;
+- `aeh_operation_status` / `aeh_operation_digest` — read-only operation state;
+- `aeh_operation_ack` — exact revision ACK by the bound Lead;
 - `aeh paseo agents --operation <id>` — explicit diagnostic view of concrete agents;
 - `aeh operation wait` — synchronous compatibility/recovery only;
 - `aeh operation cancel` — explicit cancellation.
 
+The tool schema is the syntactic contract, CapabilityRegistry records available authority/capabilities, an operational skill is the procedure, and the deterministic controller is final lifecycle/security authority. Tool-start schemas derive route effects and prohibit caller-controlled delivery authority; consult `aeh-operation-control` for operation start, lineage, portfolio, recovery, ACK, and delivery procedure.
+
 Do not infer workflow completion from a reviewer looking idle in the UI. Do not infer liveness from a single callback. Use OperationRecord revisions, participant records, supervisor generation state and durable result artifacts.
 
 ## Self-modification

package/templates/project.yaml

@@ -81,6 +81,7 @@ orchestration:
     provider: opencode
     maxRepairAttempts: 2
   operations:
+    ownerBoundaryScope: CHAIN_SCOPED_BOUNDARY
     liveness:
       hardDeadlineMs: 28800000
       progressLeaseMs: 900000

package/dist/releases/release-1790997634971-16248-5dd74527/agents/outputContracts.d.ts

@@ -1,397 +0,0 @@
-import { z } from "zod";
-declare const workUnitOutputSchema: z.ZodObject<{
-    id: z.ZodString;
-    objective: z.ZodString;
-    scope: z.ZodArray<z.ZodString>;
-    dependencies: z.ZodArray<z.ZodString>;
-    requirementRefs: z.ZodArray<z.ZodString>;
-    acceptanceRefs: z.ZodArray<z.ZodString>;
-    competencies: z.ZodArray<z.ZodString>;
-    riskTags: z.ZodArray<z.ZodString>;
-    changeKinds: z.ZodArray<z.ZodEnum<{
-        source: "source";
-        test: "test";
-        schema: "schema";
-        config: "config";
-        docs: "docs";
-        dependency: "dependency";
-        infrastructure: "infrastructure";
-        security: "security";
-    }>>;
-    risk: z.ZodEnum<{
-        high: "high";
-        medium: "medium";
-        low: "low";
-        critical: "critical";
-    }>;
-    resourceClaims: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        resource: z.ZodString;
-        mode: z.ZodEnum<{
-            SHARED_READ: "SHARED_READ";
-            EXCLUSIVE_WRITE: "EXCLUSIVE_WRITE";
-            ORDERED_SEQUENCE: "ORDERED_SEQUENCE";
-        }>;
-        order: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export declare const plannerOutputSchema: z.ZodObject<{
-    workUnits: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        objective: z.ZodString;
-        scope: z.ZodArray<z.ZodString>;
-        dependencies: z.ZodArray<z.ZodString>;
-        requirementRefs: z.ZodArray<z.ZodString>;
-        acceptanceRefs: z.ZodArray<z.ZodString>;
-        competencies: z.ZodArray<z.ZodString>;
-        riskTags: z.ZodArray<z.ZodString>;
-        changeKinds: z.ZodArray<z.ZodEnum<{
-            source: "source";
-            test: "test";
-            schema: "schema";
-            config: "config";
-            docs: "docs";
-            dependency: "dependency";
-            infrastructure: "infrastructure";
-            security: "security";
-        }>>;
-        risk: z.ZodEnum<{
-            high: "high";
-            medium: "medium";
-            low: "low";
-            critical: "critical";
-        }>;
-        resourceClaims: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            version: z.ZodLiteral<1>;
-            resource: z.ZodString;
-            mode: z.ZodEnum<{
-                SHARED_READ: "SHARED_READ";
-                EXCLUSIVE_WRITE: "EXCLUSIVE_WRITE";
-                ORDERED_SEQUENCE: "ORDERED_SEQUENCE";
-            }>;
-            order: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>>;
-    affectedAreas: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    reviewDimensions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    validationRequirements: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        id: z.ZodString;
-        property: z.ZodString;
-        kind: z.ZodEnum<{
-            architecture: "architecture";
-            command: "command";
-            "unit-test": "unit-test";
-            "integration-test": "integration-test";
-            bdd: "bdd";
-            "contract-test": "contract-test";
-            "browser-test": "browser-test";
-            "static-security": "static-security";
-            "dependency-security": "dependency-security";
-            policy: "policy";
-            "visual-test": "visual-test";
-        }>;
-        scope: z.ZodArray<z.ZodString>;
-        evidenceNeeded: z.ZodArray<z.ZodString>;
-        requirementRefs: z.ZodArray<z.ZodString>;
-        acceptanceRefs: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>>;
-    outOfScopeImprovements: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    formalizationNeed: z.ZodOptional<z.ZodEnum<{
-        NONE: "NONE";
-        REQUIRED: "REQUIRED";
-        RECOMMENDED: "RECOMMENDED";
-    }>>;
-    formalizationReason: z.ZodOptional<z.ZodEnum<{
-        PRODUCT_UNCERTAINTY: "PRODUCT_UNCERTAINTY";
-        ARCHITECTURE_UNCERTAINTY: "ARCHITECTURE_UNCERTAINTY";
-        REQUIREMENT_CONTRADICTION: "REQUIREMENT_CONTRADICTION";
-        CROSS_COMPONENT_DESIGN: "CROSS_COMPONENT_DESIGN";
-        OTHER: "OTHER";
-    }>>;
-    formalizationEvidenceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export declare const knowledgePackOutputSchema: z.ZodObject<{
-    pack: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        cacheKey: z.ZodString;
-        topic: z.ZodString;
-        claims: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            statement: z.ZodString;
-            competency: z.ZodString;
-            confidence: z.ZodEnum<{
-                high: "high";
-                medium: "medium";
-                low: "low";
-            }>;
-        }, z.core.$strict>>;
-        sources: z.ZodArray<z.ZodObject<{
-            uri: z.ZodString;
-            kind: z.ZodEnum<{
-                unknown: "unknown";
-                official: "official";
-                repository: "repository";
-                "public-code": "public-code";
-            }>;
-            version: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        retrievedAt: z.ZodString;
-        packDigest: z.ZodString;
-    }, z.core.$strict>;
-    skillCandidate: z.ZodOptional<z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        id: z.ZodString;
-        competency: z.ZodString;
-        procedure: z.ZodArray<z.ZodString>;
-        sourcePackDigest: z.ZodString;
-        procedureEvidence: z.ZodArray<z.ZodObject<{
-            stepIndex: z.ZodNumber;
-            claimIds: z.ZodArray<z.ZodString>;
-            sourceUris: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type KnowledgePackOutput = z.infer<typeof knowledgePackOutputSchema>;
-export declare const explorerOutputSchema: z.ZodObject<{
-    summary: z.ZodString;
-    relevantFiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        symbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        reason: z.ZodString;
-    }, z.core.$strip>>>;
-    findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodEnum<{
-            BLOCKED: "BLOCKED";
-            PARTIAL: "PARTIAL";
-            CONFIRMED: "CONFIRMED";
-            NOT_REPRODUCED: "NOT_REPRODUCED";
-        }>;
-        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        notes: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    moduleBoundaries: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    tests: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    openQuestions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const specAuthoringOutputSchema: z.ZodObject<{
-    change: z.ZodString;
-    status: z.ZodEnum<{
-        BLOCKED: "BLOCKED";
-        READY: "READY";
-    }>;
-    artifacts: z.ZodObject<{
-        proposal: z.ZodOptional<z.ZodString>;
-        design: z.ZodOptional<z.ZodString>;
-        tasks: z.ZodOptional<z.ZodString>;
-        specs: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            capability: z.ZodString;
-            content: z.ZodString;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>;
-    requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    unresolvedDecisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    decisionRequests: z.ZodArray<z.ZodObject<{
-        issue: z.ZodString;
-        whatTried: z.ZodArray<z.ZodString>;
-        whyUnresolvable: z.ZodString;
-        choices: z.ZodArray<z.ZodObject<{
-            choiceId: z.ZodString;
-            label: z.ZodString;
-            description: z.ZodString;
-            consequences: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-        workThatCanContinue: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-    validationReady: z.ZodBoolean;
-}, z.core.$strict>;
-export declare const implementerOutputSchema: z.ZodObject<{
-    filesChanged: z.ZodArray<z.ZodString>;
-    behaviorImplemented: z.ZodArray<z.ZodString>;
-    decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    assumptions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    validationCommands: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    followUp: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    contractSync: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const findingSchema: z.ZodObject<{
-    id: z.ZodString;
-    severity: z.ZodEnum<{
-        high: "high";
-        medium: "medium";
-        low: "low";
-        critical: "critical";
-        note: "note";
-    }>;
-    category: z.ZodString;
-    location: z.ZodObject<{
-        file: z.ZodString;
-        startLine: z.ZodOptional<z.ZodNumber>;
-        endLine: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    evidence: z.ZodString;
-    impact: z.ZodString;
-    recommendedFix: z.ZodString;
-    requiredCompetencies: z.ZodArray<z.ZodString>;
-    reviewDimensions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    exceptionType: z.ZodOptional<z.ZodEnum<{
-        IMPLEMENTATION_DEFECT: "IMPLEMENTATION_DEFECT";
-        SPEC_CONTRADICTION: "SPEC_CONTRADICTION";
-        REQUIRES_PRODUCT_DECISION: "REQUIRES_PRODUCT_DECISION";
-        BLOCKED_EXTERNAL: "BLOCKED_EXTERNAL";
-        SYSTEM_FAILURE: "SYSTEM_FAILURE";
-    }>>;
-}, z.core.$strip>;
-export declare const reviewerOutputSchema: z.ZodObject<{
-    verdict: z.ZodEnum<{
-        FAIL: "FAIL";
-        PASS: "PASS";
-        PASS_WITH_WARNINGS: "PASS_WITH_WARNINGS";
-    }>;
-    findings: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        severity: z.ZodEnum<{
-            high: "high";
-            medium: "medium";
-            low: "low";
-            critical: "critical";
-            note: "note";
-        }>;
-        category: z.ZodString;
-        location: z.ZodObject<{
-            file: z.ZodString;
-            startLine: z.ZodOptional<z.ZodNumber>;
-            endLine: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
-        evidence: z.ZodString;
-        impact: z.ZodString;
-        recommendedFix: z.ZodString;
-        requiredCompetencies: z.ZodArray<z.ZodString>;
-        reviewDimensions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        exceptionType: z.ZodOptional<z.ZodEnum<{
-            IMPLEMENTATION_DEFECT: "IMPLEMENTATION_DEFECT";
-            SPEC_CONTRADICTION: "SPEC_CONTRADICTION";
-            REQUIRES_PRODUCT_DECISION: "REQUIRES_PRODUCT_DECISION";
-            BLOCKED_EXTERNAL: "BLOCKED_EXTERNAL";
-            SYSTEM_FAILURE: "SYSTEM_FAILURE";
-        }>>;
-    }, z.core.$strip>>;
-    finalizationSafety: z.ZodEnum<{
-        BLOCKED: "BLOCKED";
-        SAFE: "SAFE";
-        RISK_KNOWN: "RISK_KNOWN";
-    }>;
-    confidence: z.ZodOptional<z.ZodString>;
-    followUp: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const validatorOutputSchema: z.ZodObject<{
-    verdict: z.ZodEnum<{
-        FAIL: "FAIL";
-        PASS: "PASS";
-        WARN: "WARN";
-    }>;
-    checks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodEnum<{
-            FAIL: "FAIL";
-            PASS: "PASS";
-            WARN: "WARN";
-            SKIP: "SKIP";
-        }>;
-        evidence: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const recoveryOutputSchema: z.ZodObject<{
-    failureType: z.ZodEnum<{
-        PATCH_CONTEXT_MISMATCH: "PATCH_CONTEXT_MISMATCH";
-        TOOL_FAILURE: "TOOL_FAILURE";
-        MISSING_CONTEXT: "MISSING_CONTEXT";
-        WRONG_AGENT: "WRONG_AGENT";
-        VALIDATION_FAILURE: "VALIDATION_FAILURE";
-        REVIEW_FAILURE: "REVIEW_FAILURE";
-        AMBIGUOUS_OUTPUT: "AMBIGUOUS_OUTPUT";
-        CONFLICTING_RESULTS: "CONFLICTING_RESULTS";
-    }>;
-    rationale: z.ZodString;
-    nextAction: z.ZodString;
-}, z.core.$strip>;
-export declare const orchestratorOutputSchema: z.ZodObject<{
-    summary: z.ZodString;
-    delegatedAgents: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    validationStatus: z.ZodOptional<z.ZodString>;
-    unresolved: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    finalizationSafe: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const supervisorOutputSchema: z.ZodObject<{
-    summary: z.ZodString;
-    consolidatedFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        severity: z.ZodEnum<{
-            high: "high";
-            medium: "medium";
-            low: "low";
-            critical: "critical";
-            note: "note";
-        }>;
-        category: z.ZodString;
-        location: z.ZodObject<{
-            file: z.ZodString;
-            startLine: z.ZodOptional<z.ZodNumber>;
-            endLine: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
-        evidence: z.ZodString;
-        impact: z.ZodString;
-        recommendedFix: z.ZodString;
-        requiredCompetencies: z.ZodArray<z.ZodString>;
-        reviewDimensions: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        exceptionType: z.ZodOptional<z.ZodEnum<{
-            IMPLEMENTATION_DEFECT: "IMPLEMENTATION_DEFECT";
-            SPEC_CONTRADICTION: "SPEC_CONTRADICTION";
-            REQUIRES_PRODUCT_DECISION: "REQUIRES_PRODUCT_DECISION";
-            BLOCKED_EXTERNAL: "BLOCKED_EXTERNAL";
-            SYSTEM_FAILURE: "SYSTEM_FAILURE";
-        }>>;
-    }, z.core.$strip>>>;
-    sourceFindingIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    conflicts: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        summary: z.ZodString;
-        sources: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>>;
-    missingEvidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    unresolved: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    roadmap: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        phase: z.ZodString;
-        priority: z.ZodEnum<{
-            P0: "P0";
-            P1: "P1";
-            P2: "P2";
-            P3: "P3";
-        }>;
-        actions: z.ZodArray<z.ZodString>;
-        findingIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
-    finalizationSafety: z.ZodEnum<{
-        BLOCKED: "BLOCKED";
-        SAFE: "SAFE";
-        RISK_KNOWN: "RISK_KNOWN";
-    }>;
-}, z.core.$strip>;
-export type WorkUnitOutput = z.infer<typeof workUnitOutputSchema>;
-export type PlannerOutput = z.infer<typeof plannerOutputSchema>;
-export type ExplorerOutput = z.infer<typeof explorerOutputSchema>;
-export type SpecAuthoringOutput = z.infer<typeof specAuthoringOutputSchema>;
-export type NormalizedFinding = z.infer<typeof findingSchema>;
-export type ReviewerOutput = z.infer<typeof reviewerOutputSchema>;
-export type SupervisorOutput = z.infer<typeof supervisorOutputSchema>;
-export declare function validateAgentOutput(contractName: string, value: unknown): {
-    ok: boolean;
-    value?: unknown;
-    issues: string[];
-};
-export declare function knownOutputContracts(): string[];
-export declare function outputJsonSchema(contractName: string): Record<string, unknown> | undefined;
-export {};

package/dist/releases/release-1790997634971-16248-5dd74527/audit/intentDecision.d.ts

@@ -1,67 +0,0 @@
-import { z } from "zod";
-export declare const semanticIntentValues: readonly ["informational", "audit", "change", "run", "status", "cancel"];
-export type SemanticIntent = (typeof semanticIntentValues)[number];
-export declare const intentDecisionSourceValues: readonly ["lead-semantic", "explicit-cli", "heuristic-fallback"];
-export type IntentDecisionSource = (typeof intentDecisionSourceValues)[number];
-export declare const intentDecisionResolutionValues: readonly ["resolved", "ambiguous", "unresolved-reference"];
-export type IntentDecisionResolution = (typeof intentDecisionResolutionValues)[number];
-export declare const intentDecisionV1Schema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    source: z.ZodEnum<{
-        "lead-semantic": "lead-semantic";
-        "explicit-cli": "explicit-cli";
-        "heuristic-fallback": "heuristic-fallback";
-    }>;
-    userTurnId: z.ZodOptional<z.ZodString>;
-    intent: z.ZodEnum<{
-        status: "status";
-        audit: "audit";
-        informational: "informational";
-        change: "change";
-        run: "run";
-        cancel: "cancel";
-    }>;
-    requestedOutcome: z.ZodString;
-    effects: z.ZodObject<{
-        evaluate: z.ZodBoolean;
-        mutateRepository: z.ZodBoolean;
-        executePreparedTask: z.ZodBoolean;
-        deliver: z.ZodBoolean;
-    }, z.core.$strict>;
-    continuation: z.ZodOptional<z.ZodObject<{
-        operationId: z.ZodOptional<z.ZodString>;
-        findingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        taskId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    confidence: z.ZodOptional<z.ZodNumber>;
-    resolution: z.ZodDefault<z.ZodEnum<{
-        resolved: "resolved";
-        ambiguous: "ambiguous";
-        "unresolved-reference": "unresolved-reference";
-    }>>;
-}, z.core.$strict>;
-export type IntentDecisionV1 = z.infer<typeof intentDecisionV1Schema>;
-export type IntentDecisionRoute = SemanticIntent;
-export interface IntentDecisionValidationSuccess {
-    ok: true;
-    value: IntentDecisionV1;
-}
-export interface IntentDecisionValidationFailure {
-    ok: false;
-    issues: string[];
-}
-export type IntentDecisionValidation = IntentDecisionValidationSuccess | IntentDecisionValidationFailure;
-export declare class InvalidIntentDecisionError extends Error {
-    readonly code = "INVALID_INTENT_DECISION";
-    constructor(message: string);
-}
-/**
- * Validate only the lead's typed semantic decision. This function deliberately
- * does not accept a human request and never performs natural-language parsing.
- */
-export declare function validateIntentDecision(value: unknown): IntentDecisionValidation;
-export declare function parseIntentDecision(value: unknown): IntentDecisionV1;
-export declare function assertIntentDecisionForRoute(value: unknown, route: IntentDecisionRoute): IntentDecisionV1;
-export declare function createIntentDecision(intent: IntentDecisionRoute, requestedOutcome: string, source: IntentDecisionSource, options?: Partial<Pick<IntentDecisionV1, "userTurnId" | "continuation" | "constraints" | "confidence" | "resolution" | "effects">>): IntentDecisionV1;
-export declare function defaultEffects(intent: IntentDecisionRoute): IntentDecisionV1["effects"];