opencode-swarm 7.123.0 → 7.125.0

package/dist/memory/sqlite-provider.d.ts

@@ -18,6 +18,14 @@ export interface SQLiteJsonlImportResult {
 export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryProposalStore {
     readonly name = "sqlite";
     private readonly rootDirectory;
+    /**
+     * #1850: when set, the provider serves a cohort-shared store rather than
+     * the worktree-local `.swarm/memory`. Cohort roots live under the platform
+     * data dir (`<dataDir>/links/<linkId>/memory`) and bypass
+     * `validateSwarmPath` by construction (the resolver sanitizes the linkId).
+     * `null` for local-root providers (today's behavior, still validated).
+     */
+    private readonly cohortRoot;
     private readonly config;
     private initialized;
     private initPromise;
@@ -32,7 +40,24 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private lastAutomaticJsonlMigration;
     private recallCountSinceLastCompaction;
     private isCompacting;
-    constructor(rootDirectory: string, config?: Partial<MemoryConfig>);
+    constructor(rootDirectory: string, config?: Partial<MemoryConfig>, 
+    /**
+     * #1850: optional cohort root. When provided, the provider opens the DB
+     * at `<cohortRoot>/memory.db` and bypasses `validateSwarmPath` (the
+     * cohort root is resolver-constructed from a sanitized linkId, not a
+     * user-supplied path). When omitted, the provider uses the worktree
+     * `.swarm` path with full `validateSwarmPath` enforcement (today's
+     * behavior).
+     */
+    vettedCohortRoot?: string | null);
+    /**
+     * #1850 (critic GAP-5): explicit cohort-root path branch.
+     * - cohort root → `<cohortRoot>/memory.db` (NO validateSwarmPath — the
+     *   cohort root is a platform-data-dir path constructed by the resolver
+     *   from a sanitized linkId, never from user input).
+     * - local root → existing behavior: strip `.swarm/` prefix, pass through
+     *   `validateSwarmPath` to enforce `.swarm` containment.
+     */
     private databasePath;
     initialize(): Promise<void>;
     private doInitialize;
@@ -57,6 +82,23 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     }): Promise<MemoryProposal[]>;
     applyCuratorDecision(decision: ResolvedCuratorMemoryDecision): Promise<AppliedMemoryChange>;
     close(): void;
+    /**
+     * #1850 (critic CONCERN-3): checkpoint the WAL into the main DB, then
+     * close the handle. Used by the memory family migration engine before it
+     * copies the DB file, so the copy reflects all committed writes and is not
+     * mid-checkpoint. After this call, the provider is closed and must be
+     * re-opened (the migration engine re-creates it via the pool).
+     *
+     * Returns the absolute paths to copy: `memory.db` plus any non-empty
+     * `-wal`/`-shm` sidecars (after a TRUNCATE checkpoint the WAL is typically
+     * empty; if it is not, copying it alongside the DB is still correct because
+     * SQLite recovers from WAL on next open).
+     */
+    checkpointCloseSnapshot(): {
+        dbPath: string;
+        walPath: string | null;
+        shmPath: string | null;
+    };
     /**
      * Re-embed all durable memory records with the current embedding provider
      * model, update the stored global model_version, and clear the embedding
@@ -94,6 +136,21 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private loadMemories;
     private loadProposals;
     private writeMemory;
+    /**
+     * #1850: write a monotonic generation marker so siblings re-open their
+     * in-memory mirror. Fire-and-forget; failures are non-fatal (peers simply
+     * revalidate on the next pointer-stat change or TTL expiry).
+     */
+    private bumpCohortGeneration;
+    /**
+     * #1850 (reviewer important fix): read `memory-cohort-config.json` and fail
+     * closed if the stored provider/embedding/redaction fingerprint disagrees
+     * with this worktree's config (acceptance #10). Absent file = first link
+     * (permissive — the linker writes it immediately after migration). A
+     * malformed file is also permissive (fail-open never strands memory, but
+     * a mismatch is a hard error).
+     */
+    private assertCohortConfigFingerprint;
     private writeMemoryFts;
     private writeMemoryVec;
     private deleteMemoryFts;

package/dist/memory/storage-root.d.ts

@@ -0,0 +1,93 @@
+/**
+ * #1850 Linked Knowledge 5/5: vetted memory storage-root capability.
+ *
+ * Problem: when cohort memory sharing is opted in, the memory provider must
+ * open a database at a cohort-scoped root (under the platform data dir), not
+ * the worktree's `.swarm/memory`. But accepting an arbitrary external path
+ * would violate `validateSwarmPath` and `.swarm` containment (AGENTS.md
+ * invariant #4, issue #1850 acceptance #3).
+ *
+ * Resolution: a narrow discriminated union `VettedMemoryRoot` that can only
+ * represent one of two validated shapes:
+ *   - `{kind:'local'}`  — the worktree's `.swarm/memory` root (today's path,
+ *     still gated by `validateSwarmPath` in the provider constructors).
+ *   - `{kind:'cohort'}` — a cohort root derived from the #1846 cohort
+ *     identity via the sanitized linkId. Constructed only by
+ *     `resolveVettedMemoryRoot` from the memory-link pointer; there is no
+ *     public `openMemoryAt(arbitraryPath)` entry.
+ *
+ * Cohort roots live under `<dataDir>/links/<linkId>/memory/` — the SAME shared
+ * store directory used by knowledge linking, namespaced under `memory/`. The
+ * `validateSwarmPath` invariant is preserved by construction: cohort roots are
+ * never passed through it (they are platform-data-dir paths, not `.swarm`
+ * paths), and local roots continue to flow through the existing validation.
+ *
+ * This module is sync-only and side-effect-free (a pointer read) so it is safe
+ * to call from the lazy gateway constructor on the plugin hot path.
+ */
+import type { MemoryConfig } from './config.js';
+import { type MemoryLinkPointer } from './memory-link.js';
+/**
+ * The vetted root. `directory` is always the worktree's project root (so
+ * providers can still derive auxiliary per-worktree paths when needed); `root`
+ * is the resolved storage root (worktree `.swarm` for local, cohort dir for
+ * cohort).
+ */
+export type VettedMemoryRoot = {
+    kind: 'local';
+    /** Resolved worktree `.swarm` directory (parent of `storageDir`). */
+    root: string;
+    /** Original worktree project root (ctx.directory). */
+    directory: string;
+} | {
+    kind: 'cohort';
+    /** Cohort memory root: `<dataDir>/links/<linkId>/memory`. */
+    cohortRoot: string;
+    /** Canonical cohort id from #1846 (shared by all sibling worktrees). */
+    cohortId: string;
+    /** Monotonic link generation (bumped on link/unlink; aids revalidation). */
+    generation: number;
+    /** Sanitized linkId (the cohort directory segment). */
+    linkId: string;
+    /** Original worktree project root (ctx.directory). */
+    directory: string;
+};
+/**
+ * Resolve the vetted memory root for a worktree. Sync, side-effect-free.
+ *
+ * Decision tree:
+ *  1. If `config.link?.enabled !== true` → local (today's behavior).
+ *  2. Read the memory-link pointer. If absent or malformed → local.
+ *  3. If the pointer resolves to a cohort store → cohort root under
+ *     `<resolveMemoryStoreDir(directory)>/memory`. `resolveMemoryStoreDir`
+ *     already canonicalizes via `path.resolve` and revalidates the pointer
+ *     stat on cache hits (mirrors `resolveKnowledgeStoreDir` in
+ *     `src/hooks/knowledge-link.ts:396`).
+ *
+ * The cohort memory root is `<resolveMemoryStoreDir(directory)>/memory` — a
+ * `memory/` subdirectory of the shared link dir, sibling to the knowledge
+ * family files. This keeps knowledge and memory in the same cohort container
+ * without colliding filenames.
+ */
+export declare function resolveVettedMemoryRoot(directory: string, config: Pick<MemoryConfig, 'link'> | Partial<Pick<MemoryConfig, 'link'>>): VettedMemoryRoot;
+/**
+ * Backward-compat shim: wraps a raw directory into a local vetted root. Emits
+ * a debug log so incomplete wiring (a caller that should have resolved a vetted
+ * root itself) is visible during development (critic CONCERN-5).
+ */
+export declare function wrapLocalRoot(directory: string): VettedMemoryRoot;
+/** Type guard for the cohort branch. */
+export declare function isCohortRoot(root: VettedMemoryRoot): root is Extract<VettedMemoryRoot, {
+    kind: 'cohort';
+}>;
+/** Type guard for the local branch. */
+export declare function isLocalRoot(root: VettedMemoryRoot): root is Extract<VettedMemoryRoot, {
+    kind: 'local';
+}>;
+/** Return the resolved storage path for a given root (no validation). */
+export declare function rootStoragePath(root: VettedMemoryRoot): string;
+export declare const _internals: {
+    resolveVettedMemoryRoot: typeof resolveVettedMemoryRoot;
+    wrapLocalRoot: typeof wrapLocalRoot;
+};
+export type { MemoryLinkPointer };

package/dist/memory/types.d.ts

@@ -1,4 +1,4 @@
-export type MemoryScopeType = 'global_user' | 'workspace' | 'project' | 'repository' | 'run' | 'agent';
+export type MemoryScopeType = 'global_user' | 'workspace' | 'project' | 'repository' | 'run' | 'agent' | 'cohort';
 export interface MemoryScopeRef {
     type: MemoryScopeType;
     userId?: string;
@@ -8,6 +8,10 @@ export interface MemoryScopeRef {
     repoRoot?: string;
     runId?: string;
     agentId?: string;
+    /** Canonical cohort id from `resolveCohortId` (#1850). Set when
+     * `type === 'cohort'`. Required for cohort-scoped records so the scope key
+     * and recall filters distinguish different cohorts. */
+    cohortId?: string;
 }
 export type MemoryKind = 'user_preference' | 'project_fact' | 'architecture_decision' | 'repo_convention' | 'api_finding' | 'code_pattern' | 'test_pattern' | 'failure_pattern' | 'security_note' | 'evidence' | 'todo' | 'scratch';
 export interface MemorySource {
@@ -35,6 +39,21 @@ export interface MemoryRecord {
     supersededBy?: string;
     contentHash: string;
     metadata: Record<string, unknown>;
+    /** Canonical cohort id the record belongs to. Matches `scope.cohortId`
+     * when `scope.type === 'cohort'`. */
+    cohortId?: string;
+    /** Session id of the producer (when policy permits retention). */
+    producerSessionId?: string;
+    /** Agent role of the producer. */
+    producerAgentRole?: string;
+    /** Redaction policy version at write time (from REDACTION_POLICY_VERSION). */
+    redactionPolicyVersion?: number;
+    /** Memory schema version at write time. */
+    schemaVersion?: number;
+    /** Provider name at write time (`'sqlite'` | `'local-jsonl'`). */
+    providerVersion?: string;
+    /** Source git revision of the producer, when available. */
+    sourceRevision?: string;
 }
 export interface MemoryProposal {
     id: string;

package/dist/services/knowledge-diagnostics.d.ts

@@ -132,6 +132,31 @@ export interface KnowledgeDebugMeta {
          */
         pending_proposals: number;
     };
+    /**
+     * #1850: memory cohort link health. Distinct from the knowledge `cohort`
+     * block so diagnostics can report knowledge-link and memory-link
+     * independently. Carries provider/config fingerprint agreement so an
+     * operator can detect cohort divergence. No record text is emitted here
+     * (diagnostics-no-leakage discipline, acceptance #13).
+     */
+    memory: {
+        linked: boolean;
+        pointer_version: 1 | 2 | null;
+        link_id: string | null;
+        cohort_id: string | null;
+        identity_source: 'remote' | 'git-common-dir' | 'path' | null;
+        degraded: boolean;
+        shared_root: string | null;
+        generation: number | null;
+        /** Provider name from config ('sqlite' | 'local-jsonl'). */
+        provider: string | null;
+        /**
+         * #1850 (KC-002): config fingerprint agreement — true when this
+         * worktree's config matches the cohort's stored fingerprint, false on
+         * mismatch, null when not checked (unlinked or file absent).
+         */
+        config_fingerprint_match: boolean | null;
+    };
 }
 /**
  * Compute the debug-metadata block for the knowledge system. Best-effort: never

package/dist/services/status-service.d.ts

@@ -91,6 +91,22 @@ export interface StatusData {
         sharedRoot?: string;
         generation?: number;
     };
+    /**
+     * #1850: memory cohort link status. Distinct from `cohort` (knowledge link)
+     * so status can distinguish knowledge-linked from memory-linked (acceptance
+     * #2). Carries provider/config/privacy health fields.
+     */
+    memoryCohort?: {
+        linked: boolean;
+        linkId?: string;
+        cohortId?: string;
+        identitySource?: 'remote' | 'git-common-dir' | 'path';
+        degraded?: boolean;
+        sharedRoot?: string;
+        generation?: number;
+        provider?: string;
+        configFingerprintMatch?: boolean;
+    };
 }
 /**
  * Get status data from the swarm directory.

package/dist/tools/complete-pr-workflow.d.ts

@@ -0,0 +1,5 @@
+import { createSwarmTool } from './create-tool.js';
+export declare function executeCompletePrWorkflow(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const complete_pr_workflow: ReturnType<typeof createSwarmTool>;

package/dist/tools/dispatch-lanes.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { resolveExactMergeBase, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
 import { createParallelDispatcher } from '../parallel/dispatcher/parallel-dispatcher.js';
 import { createSwarmTool } from './create-tool.js';
 export declare const MAX_PROMPT_CHARS = 80000;
@@ -6,12 +7,18 @@ declare const LaneSchema: z.ZodObject<{
     id: z.ZodString;
     agent: z.ZodString;
     prompt: z.ZodString;
+    workflow_lane: z.ZodOptional<z.ZodString>;
+    feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 declare const DispatchLanesArgsSchema: z.ZodObject<{
     lanes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         agent: z.ZodString;
         prompt: z.ZodString;
+        workflow_lane: z.ZodOptional<z.ZodString>;
+        feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     common_prompt: z.ZodOptional<z.ZodString>;
     max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -22,6 +29,9 @@ declare const DispatchLanesAsyncArgsSchema: z.ZodObject<{
         id: z.ZodString;
         agent: z.ZodString;
         prompt: z.ZodString;
+        workflow_lane: z.ZodOptional<z.ZodString>;
+        feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     common_prompt: z.ZodOptional<z.ZodString>;
     max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -30,7 +40,15 @@ declare const DispatchLanesAsyncArgsSchema: z.ZodObject<{
     batch_id: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodString>;
     pr_head_sha: z.ZodOptional<z.ZodString>;
+    base_sha: z.ZodOptional<z.ZodString>;
+    base_ref: z.ZodOptional<z.ZodString>;
     scope: z.ZodOptional<z.ZodString>;
+    trigger_evaluation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        trigger_id: z.ZodString;
+        result: z.ZodLiteral<"MATCHED">;
+        evidence: z.ZodString;
+    }, z.core.$strict>>>;
+    feedback_inventory: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 declare const CollectLaneResultsArgsSchema: z.ZodObject<{
     batch_id: z.ZodString;
@@ -213,12 +231,16 @@ export declare const _internals: {
     getSessionOps: () => SessionOps | null;
     getGeneratedAgentNames: () => readonly string[];
     createParallelDispatcher: typeof createParallelDispatcher;
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    resolveExactMergeBase: typeof resolveExactMergeBase;
     now: () => number;
     sleep: (ms: number) => Promise<void>;
 };
 export declare const _test_exports: {
     applyCommonPrompt: typeof applyCommonPrompt;
     applyExplorerFormatSuffix: typeof applyExplorerFormatSuffix;
+    applyPrWorkflowPromptContract: typeof applyPrWorkflowPromptContract;
+    buildReadOnlyTools: typeof buildReadOnlyTools;
     buildLaneSessionCreateArgs: typeof buildLaneSessionCreateArgs;
     extractAssistantTranscript: typeof extractAssistantTranscript;
     formatError: typeof formatError;
@@ -229,6 +251,9 @@ export declare const _test_exports: {
             id: z.ZodString;
             agent: z.ZodString;
             prompt: z.ZodString;
+            workflow_lane: z.ZodOptional<z.ZodString>;
+            feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
         common_prompt: z.ZodOptional<z.ZodString>;
         max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -239,6 +264,9 @@ export declare const _test_exports: {
             id: z.ZodString;
             agent: z.ZodString;
             prompt: z.ZodString;
+            workflow_lane: z.ZodOptional<z.ZodString>;
+            feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
         common_prompt: z.ZodOptional<z.ZodString>;
         max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -247,7 +275,15 @@ export declare const _test_exports: {
         batch_id: z.ZodOptional<z.ZodString>;
         mode: z.ZodOptional<z.ZodString>;
         pr_head_sha: z.ZodOptional<z.ZodString>;
+        base_sha: z.ZodOptional<z.ZodString>;
+        base_ref: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodString>;
+        trigger_evaluation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            trigger_id: z.ZodString;
+            result: z.ZodLiteral<"MATCHED">;
+            evidence: z.ZodString;
+        }, z.core.$strict>>>;
+        feedback_inventory: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
     DEFAULT_TIMEOUT_MS: number;
     DEFAULT_ASYNC_LAUNCH_TIMEOUT_MS: number;
@@ -280,6 +316,7 @@ declare function extractAssistantTranscript(messages: Array<{
     transcriptIncomplete: boolean;
 };
 declare function nextCollectPollInterval(currentMs: number): number;
+declare function buildReadOnlyTools(): ReadOnlyToolPermissions;
 type ApplyCommonPromptResult = {
     ok: true;
     lanes: DispatchLaneSpec[];
@@ -299,6 +336,13 @@ type ApplyCommonPromptResult = {
  */
 declare function applyCommonPrompt(lanes: DispatchLaneSpec[], commonPrompt: string | undefined): ApplyCommonPromptResult;
 declare function applyExplorerFormatSuffix(lanes: DispatchLaneSpec[]): DispatchLaneSpec[];
+declare function applyPrWorkflowPromptContract(lanes: DispatchLaneSpec[], options: {
+    mode?: string;
+    prHeadSha?: string;
+    revisionDigest?: string;
+    scope?: string;
+    callerFocus?: string;
+}): ApplyCommonPromptResult;
 declare function formatError(error: unknown): string;
 declare function buildLaneSessionCreateArgs(directory: string, lane: DispatchLaneSpec, context: Pick<DispatchLanesExecutionContext, 'sessionID'>): {
     body: {

package/dist/tools/index.d.ts

@@ -86,6 +86,7 @@ export type { ClassifiedFailure, FailureClassification, FailureCluster, } from '
 export { classifyAndCluster, classifyFailure, clusterFailures, } from '../test-impact/failure-classifier.js';
 export type { FlakyTestEntry } from '../test-impact/flaky-detector.js';
 export { computeFlakyScore, detectFlakyTests, isTestQuarantined, } from '../test-impact/flaky-detector.js';
+export { complete_pr_workflow, executeCompletePrWorkflow, } from './complete-pr-workflow';
 export { epic_plan_waves } from './epic-plan-waves';
 export { epic_record_divergence } from './epic-record-divergence';
 export { epic_decide_phase } from './epic-run-phase';
@@ -98,6 +99,7 @@ export { lean_turbo_runner_status } from './lean-turbo-runner-status';
 export { lean_turbo_status } from './lean-turbo-status';
 export { lint_spec } from './lint-spec';
 export { mutation_test } from './mutation-test';
+export { executeRunPrFeedbackStageA, run_pr_feedback_stage_a, } from './run-pr-feedback-stage-a';
 export { symbols } from './symbols';
 export { type SyntaxCheckFileResult, type SyntaxCheckInput, type SyntaxCheckResult, syntax_check, syntaxCheck, } from './syntax-check';
 export { test_impact } from './test-impact';

package/dist/tools/manifest.d.ts

@@ -42,6 +42,8 @@ export declare const TOOL_MANIFEST: {
     evidence_check: () => ToolDefinition;
     check_gate_status: () => ToolDefinition;
     completion_verify: () => ToolDefinition;
+    complete_pr_workflow: () => ToolDefinition;
+    run_pr_feedback_stage_a: () => ToolDefinition;
     submit_council_verdicts: () => ToolDefinition;
     submit_phase_council_verdicts: () => ToolDefinition;
     declare_council_criteria: () => ToolDefinition;

package/dist/tools/run-pr-feedback-stage-a.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { readGitTextAtRevision, resolveCurrentGitHead, resolveExactMergeBase, resolveGitControlStateDigest, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
+import { runExternalTool } from '../utils/external-tool-runner.js';
+import { createSwarmTool } from './create-tool.js';
+declare const STAGE_A_CATEGORIES: readonly ["build", "typecheck", "lint", "diff-check", "reproduction"];
+type StageACategory = (typeof STAGE_A_CATEGORIES)[number];
+declare const OPTIONAL_STAGE_A_CATEGORIES: readonly ["build", "typecheck", "lint"];
+type OptionalStageACategory = (typeof OPTIONAL_STAGE_A_CATEGORIES)[number];
+interface StageAObligation {
+    id: string;
+    category: OptionalStageACategory;
+    workingDirectory: string;
+    source: string;
+    validatorContract?: {
+        path: string;
+        id: string;
+    };
+}
+interface ContractBaseProvenance {
+    baseRef: string;
+    baseSha: string;
+}
+declare const StageACheckSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        lint: "lint";
+        build: "build";
+        typecheck: "typecheck";
+        "diff-check": "diff-check";
+        reproduction: "reproduction";
+    }>;
+    command: z.ZodArray<z.ZodString>;
+    targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    feedback_targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feedback_item_id: z.ZodString;
+        target: z.ZodString;
+        expected_behavior: z.ZodString;
+    }, z.core.$strict>>>;
+    working_directory: z.ZodOptional<z.ZodString>;
+    obligation_id: z.ZodOptional<z.ZodString>;
+    validator_contract: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare function isPlausibleStageACommand(category: StageACategory, command: readonly string[]): boolean;
+type StageACheckInput = z.infer<typeof StageACheckSchema>;
+declare function commandMatchesObligationSource(directory: string, obligation: StageAObligation, check: StageACheckInput, contractValidated: boolean): boolean;
+/** Discover concrete workspace/category/source obligations from bounded local signals. */
+declare function discoverApplicableStageAObligations(directory: string, contractBase?: ContractBaseProvenance): StageAObligation[];
+declare function discoverApplicableStageACategories(directory: string, contractBase?: ContractBaseProvenance): OptionalStageACategory[];
+/** Execute every mandatory repository-generic Stage A category and persist receipts. */
+export declare function executeRunPrFeedbackStageA(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const _internals: {
+    runExternalTool: typeof runExternalTool;
+    readGitTextAtRevision: typeof readGitTextAtRevision;
+    resolveExactMergeBase: typeof resolveExactMergeBase;
+    resolveCurrentGitHead: typeof resolveCurrentGitHead;
+    resolveGitControlStateDigest: typeof resolveGitControlStateDigest;
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    isPlausibleStageACommand: typeof isPlausibleStageACommand;
+    discoverApplicableStageACategories: typeof discoverApplicableStageACategories;
+    discoverApplicableStageAObligations: typeof discoverApplicableStageAObligations;
+    commandMatchesObligationSource: typeof commandMatchesObligationSource;
+};
+export declare const run_pr_feedback_stage_a: ReturnType<typeof createSwarmTool>;
+export {};

package/dist/tools/tool-metadata.d.ts

@@ -99,6 +99,14 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: ("critic_oversight" | "architect")[];
     };
+    complete_pr_workflow: {
+        description: string;
+        agents: "architect"[];
+    };
+    run_pr_feedback_stage_a: {
+        description: string;
+        agents: "architect"[];
+    };
     submit_council_verdicts: {
         description: string;
         agents: never[];

package/dist/tools/write-pr-review-trigger-eval.d.ts

@@ -1,67 +1,75 @@
 import { z } from 'zod';
+import { resolveExactMergeBase, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
 import { createSwarmTool } from './create-tool';
+export declare const _internals: {
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    resolveMergeBase: typeof resolveExactMergeBase;
+};
 /** Canonical trigger IDs and display values shared with the PR-review protocol. */
 export declare const PR_REVIEW_TRIGGER_DEFINITIONS: readonly [{
-    readonly id: "architect-prompts";
-    readonly trigger_row: "agents, prompts, templates, prompt interpolation, role text";
-    readonly micro_lane: "Architect prompt integrity";
+    readonly id: "auth-identity-secrets";
+    readonly scope: "universal";
+    readonly trigger_row: "authentication, authorization, identity, sessions, permissions, secrets, cryptography";
+    readonly micro_lane: "Identity and secret boundaries";
 }, {
-    readonly id: "council-orchestration";
-    readonly trigger_row: "council, verdict, quorum, veto, synthesis";
-    readonly micro_lane: "Council orchestration";
+    readonly id: "untrusted-input-boundaries";
+    readonly scope: "universal";
+    readonly trigger_row: "parsing, serialization, queries, templates/rendering, file or network input/output";
+    readonly micro_lane: "Untrusted input and sink analysis";
 }, {
-    readonly id: "guardrail-bypass";
-    readonly trigger_row: "guardrail, gate, delegation, rate limit, approval checks";
-    readonly micro_lane: "Guardrail bypass paths";
+    readonly id: "subprocess-platform";
+    readonly scope: "universal";
+    readonly trigger_row: "subprocesses, shell commands, filesystem operations, OS/runtime-specific code";
+    readonly micro_lane: "Subprocess and platform safety";
 }, {
-    readonly id: "evidence-schema";
-    readonly trigger_row: "schema, evidence, JSONL, migrations, serializers";
-    readonly micro_lane: "Evidence schema drift";
+    readonly id: "concurrency-state";
+    readonly scope: "universal";
+    readonly trigger_row: "queues, caches, retries, transactions, locks, state machines, async coordination";
+    readonly micro_lane: "Concurrency and state transitions";
 }, {
-    readonly id: "knowledge-contract";
-    readonly trigger_row: "knowledge, curator, hive, quarantine, memory";
-    readonly micro_lane: "Knowledge base contract";
+    readonly id: "dependencies-build-release";
+    readonly scope: "universal";
+    readonly trigger_row: "dependency manifests, lockfiles, installers, build scripts, CI, packaging, deployment";
+    readonly micro_lane: "Dependency and delivery integrity";
 }, {
-    readonly id: "phase-transitions";
-    readonly trigger_row: "phase, state, plan, .swarm/state, completion markers";
-    readonly micro_lane: "Phase transition validation";
+    readonly id: "api-schema-migrations";
+    readonly scope: "universal";
+    readonly trigger_row: "public API, wire/schema/config/storage formats, migrations, feature flags";
+    readonly micro_lane: "Compatibility and migration safety";
 }, {
-    readonly id: "model-role-mapping";
-    readonly trigger_row: "model, role, prefix, tool, agent config";
-    readonly micro_lane: "Model-to-role mapping";
-}, {
-    readonly id: "config-ratchet";
-    readonly trigger_row: "config, defaults, ratchet, locks, policy flags";
-    readonly micro_lane: "Config ratchet semantics";
-}, {
-    readonly id: "url-fetch";
-    readonly trigger_row: "url, fetch, http, GitHub PR/issue parsing, package fetch";
-    readonly micro_lane: "URL sanitization and external fetch";
+    readonly id: "test-infrastructure";
+    readonly scope: "universal";
+    readonly trigger_row: "tests, mocks, fixtures, harnesses, coverage, CI matrices";
+    readonly micro_lane: "Test validity and isolation";
 }, {
-    readonly id: "git-safety";
-    readonly trigger_row: "git, branch, checkout, reset, worktree, .git";
-    readonly micro_lane: "Git safety";
+    readonly id: "ui-accessibility-i18n";
+    readonly scope: "universal";
+    readonly trigger_row: "user interfaces, interaction flows, rendering, accessibility, localization";
+    readonly micro_lane: "UI and human-interface quality";
 }, {
-    readonly id: "shell-write";
-    readonly trigger_row: "shell, exec, command parser, file writes, delete/move/copy";
-    readonly micro_lane: "Shell/write authority and path containment";
+    readonly id: "privacy-observability";
+    readonly scope: "universal";
+    readonly trigger_row: "telemetry, logs, analytics, traces, retention, diagnostics";
+    readonly micro_lane: "Privacy and observability safety";
 }, {
-    readonly id: "test-infrastructure";
-    readonly trigger_row: "test, bun, mocks, fixtures, CI matrix";
-    readonly micro_lane: "Test infrastructure";
+    readonly id: "generated-provenance";
+    readonly scope: "universal";
+    readonly trigger_row: "generated, vendored, binary, model-produced, codegen or checked-in build artifacts";
+    readonly micro_lane: "Generated artifact provenance";
 }, {
-    readonly id: "metrics-privacy";
-    readonly trigger_row: "metrics, telemetry, logs, serialized traces";
-    readonly micro_lane: "Metrics and evidence privacy";
+    readonly id: "unclassified-risk";
+    readonly scope: "universal";
+    readonly trigger_row: "any changed artifact or behavior not confidently classified by the rows above";
+    readonly micro_lane: "Unclassified high-risk fallback";
 }];
 declare const WritePrReviewTriggerEvalArgsSchema: z.ZodObject<{
     run_id: z.ZodString;
+    pr_head_sha: z.ZodString;
+    base_sha: z.ZodOptional<z.ZodString>;
+    base_ref: z.ZodOptional<z.ZodString>;
     rows: z.ZodArray<z.ZodObject<{
         trigger_id: z.ZodString;
-        result: z.ZodEnum<{
-            MATCHED: "MATCHED";
-            "NO-MATCH": "NO-MATCH";
-        }>;
+        result: z.ZodLiteral<"MATCHED">;
         evidence: z.ZodString;
         source_batch_id: z.ZodOptional<z.ZodString>;
         source_lane_id: z.ZodOptional<z.ZodString>;
@@ -69,6 +77,8 @@ declare const WritePrReviewTriggerEvalArgsSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type WritePrReviewTriggerEvalArgs = z.infer<typeof WritePrReviewTriggerEvalArgsSchema>;
 /** Validate and atomically persist the complete PR-review trigger evaluation. */
-export declare function executeWritePrReviewTriggerEval(args: unknown, directory: string): Promise<string>;
+export declare function executeWritePrReviewTriggerEval(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
 export declare const write_pr_review_trigger_eval: ReturnType<typeof createSwarmTool>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.123.0",
+	"version": "7.125.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",