@quantiya/codevibe-core 2.0.0 → 2.0.2

package/dist/orchestration-shell/team-decompose.d.ts

@@ -0,0 +1,196 @@
+import { z } from 'zod';
+import { buildImplementorArgv } from '../local-executor/implementor-argv';
+import type { LocalExecutor } from '../local-executor';
+import type { AgentKind } from '../local-executor/types';
+import type { WorkItemInput } from '../local-executor/task-group-types';
+/**
+ * The full decomposer-output shape pre-check (§3.E): `decompose:true` with ≥2
+ * well-shaped work items, OR `decompose:false` with a reason. ≥2 is the
+ * "a team is ≥2 tracks" contract (mirrors `parseTeamWorkItems`).
+ */
+export declare const WorkItemInputSchema: z.ZodDiscriminatedUnion<"decompose", [z.ZodObject<{
+    decompose: z.ZodLiteral<true>;
+    workItems: z.ZodArray<z.ZodObject<{
+        ownershipScope: z.ZodObject<{
+            write_paths: z.ZodArray<z.ZodString, "many">;
+            shared_contracts: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                access: z.ZodEnum<["write", "read"]>;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                access: "write" | "read";
+            }, {
+                path: string;
+                access: "write" | "read";
+            }>, "many">;
+            test_surfaces: z.ZodArray<z.ZodString, "many">;
+            auto_modified_files: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            shared_contracts: {
+                path: string;
+                access: "write" | "read";
+            }[];
+            write_paths: string[];
+            test_surfaces: string[];
+            auto_modified_files: string[];
+        }, {
+            shared_contracts: {
+                path: string;
+                access: "write" | "read";
+            }[];
+            write_paths: string[];
+            test_surfaces: string[];
+            auto_modified_files: string[];
+        }>;
+        implementorAgent: z.ZodEffects<z.ZodEnum<["CLAUDE", "CODEX", "GEMINI", "ANTIGRAVITY"]>, "CLAUDE" | "GEMINI" | "CODEX" | "ANTIGRAVITY", unknown>;
+        isSharedTestOwner: z.ZodBoolean;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        ownershipScope: {
+            shared_contracts: {
+                path: string;
+                access: "write" | "read";
+            }[];
+            write_paths: string[];
+            test_surfaces: string[];
+            auto_modified_files: string[];
+        };
+        implementorAgent: "CLAUDE" | "GEMINI" | "CODEX" | "ANTIGRAVITY";
+        isSharedTestOwner: boolean;
+    }, {
+        description: string;
+        ownershipScope: {
+            shared_contracts: {
+                path: string;
+                access: "write" | "read";
+            }[];
+            write_paths: string[];
+            test_surfaces: string[];
+            auto_modified_files: string[];
+        };
+        isSharedTestOwner: boolean;
+        implementorAgent?: unknown;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    decompose: true;
+    workItems: {
+        description: string;
+        ownershipScope: {
+            shared_contracts: {
+                path: string;
+                access: "write" | "read";
+            }[];
+            write_paths: string[];
+            test_surfaces: string[];
+            auto_modified_files: string[];
+        };
+        implementorAgent: "CLAUDE" | "GEMINI" | "CODEX" | "ANTIGRAVITY";
+        isSharedTestOwner: boolean;
+    }[];
+}, {
+    decompose: true;
+    workItems: {
+        description: string;
+        ownershipScope: {
+            shared_contracts: {
+                path: string;
+                access: "write" | "read";
+            }[];
+            write_paths: string[];
+            test_surfaces: string[];
+            auto_modified_files: string[];
+        };
+        isSharedTestOwner: boolean;
+        implementorAgent?: unknown;
+    }[];
+}>, z.ZodObject<{
+    decompose: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    decompose: false;
+}, {
+    reason: string;
+    decompose: false;
+}>]>;
+/** One work item the decomposer emits — the real wire `WorkItemInput` field
+ *  `implementorAgent` plus a desktop-local `description` brief. */
+export type DecomposerWorkItem = WorkItemInput & {
+    description: string;
+};
+export type DecomposerResult = {
+    decompose: true;
+    workItems: DecomposerWorkItem[];
+} | {
+    decompose: false;
+    reason: string;
+};
+/**
+ * Read the implementor's FINAL message text per-agent (§3.B / L9). Unlike
+ * `extractAgentSummary` (which returns '' for Codex because the diff is the
+ * single-impl contract), the DECOMPOSER needs the actual reply text — so for
+ * Codex we read AND unlink the `--output-last-message` temp file. A Codex
+ * decomposer would otherwise always parse-fail on its `--json` JSONL stdout.
+ *   - Claude  → `capture.kind === 'stdout'` → `handle.stdout()`.
+ *   - Codex   → `capture.kind === 'file'`   → read+unlink the temp file.
+ *   - Gemini  → stdout, unwrap the `{ response }` JSON envelope.
+ * NEVER throws — a capture error returns '' (→ the caller's parse-fail →
+ * single-task fallback).
+ */
+export declare function readImplementorFinalMessage(plan: ReturnType<typeof buildImplementorArgv>, handle: {
+    stdout: () => string;
+}, agent: AgentKind, exitCode: number): Promise<string>;
+/**
+ * Build the decomposition prompt fed to the local decomposer on stdin (§3.B).
+ * `brief` is the composed lossless implementation brief (§3.D step 0).
+ * `availableAgents` is the DETECTED set (§3.C) — the strengths list is filtered
+ * to it, and the decomposer is told to pick `implementorAgent` from it.
+ */
+export declare function buildDecomposerPrompt(brief: string, availableAgents: AgentKind[]): string;
+/**
+ * #590 — append a deterministic "allowed test files" line to a track's brief so
+ * the implementor agent writes its own-module tests at the EXACT declared
+ * `test_surfaces` paths (which `filesOutsideWriteScope` then accepts in-lane).
+ * Belt-and-suspenders to the decomposer-prompt instruction: even if the model's
+ * `description` prose omits the test paths, the agent is told them verbatim, so a
+ * test write lands inside the declared lane rather than tripping out_of_scope_write.
+ * No-op (returns the brief unchanged) when the track declares no test surfaces.
+ */
+export declare function appendTestSurfaceGuidance(brief: string, testSurfaces: string[]): string;
+/**
+ * Parse + shape-validate a decomposer reply into a `DecomposerResult`. Returns
+ * null when the text contains no parseable/valid JSON (the caller retries once,
+ * then falls back to single). The full `WorkItemInputSchema` (§3.E) is applied
+ * here so a deep-malformed shape fails the parse LOCALLY (NOT later as an
+ * `unknown_create_error`).
+ */
+export declare function parseDecomposerResult(text: string): DecomposerResult | null;
+export interface RunLocalDecomposerDeps {
+    localExecutor: LocalExecutor;
+    /** Canonicalized real working dir (the repo) — the decomposer reads the tree. */
+    workingDir: string;
+}
+/**
+ * Run the local decomposition pass (§3.B). Spawns the FIRST available agent in
+ * read-only `plan` mode via the PRODUCTION `LocalExecutor.spawnImplementor` path
+ * (NOT `AdapterRegistry.launchImplementor`, which has no prompt/capture). The
+ * decomposition prompt rides stdin; output is captured per-agent via
+ * `readImplementorFinalMessage` and tolerant-parsed. On a parse failure it
+ * retries ONCE with a "JSON only" suffix; a second failure → `{ decompose:false }`
+ * (the caller treats that as the single-task fallback).
+ *
+ * `availableAgents` is the DETECTED set (§3.C). The decomposer itself runs as
+ * the first detected agent; CP-7 engages because `role:'implementor'` + a
+ * (synthetic) `taskId` are passed.
+ */
+export declare function runLocalDecomposer(deps: RunLocalDecomposerDeps, brief: string, availableAgents: AgentKind[]): Promise<DecomposerResult>;
+/**
+ * Validate + normalize each work item's `implementorAgent` against the DETECTED
+ * agent set (§3.C — v1 is DETECTED-ONLY; NO capability-health filtering, NO
+ * per-spawn auth-recheck). For each item: `.toUpperCase()`-normalize the
+ * suggested agent; keep it if detected; else SUBSTITUTE the first detected
+ * agent. If NO agent is detected → `null` (the caller falls back to single).
+ * Returns NEW work items (does not mutate the inputs).
+ */
+export declare function validateAgentAvailability(workItems: DecomposerWorkItem[], detected: AgentKind[]): DecomposerWorkItem[] | null;