qlogicagent 2.16.4 → 2.16.6

package/dist/types/cli/community-resource-installer.d.ts

@@ -1,8 +1,8 @@
 import type { CommunityInstallResolution } from "../runtime/community/community-consent-client.js";
-import { type InstalledCommunityPetResource } from "../runtime/pet/pet-community-assets.js";
+import { type InstalledCommunityPet } from "../runtime/pet/pet-community-assets.js";
 import { type CommunityInstalledResource, type InstallCommunitySkillOptions } from "./community-skill-installer.js";
 import { type CommunityWorkflowBundlePayload } from "./community-workflow-installer.js";
-export type CommunityInstalledAnyResource = CommunityInstalledResource | InstalledCommunityPetResource | CommunityWorkflowBundlePayload;
+export type CommunityInstalledAnyResource = CommunityInstalledResource | InstalledCommunityPet | CommunityWorkflowBundlePayload;
 export interface CommunityMcpInstallPreview {
     kind: "mcp";
     mode: "preview";
@@ -27,4 +27,6 @@ export interface CommunityExecutableLauncherGate {
     autoRunBlocked: true;
     manifest: unknown;
 }
-export declare function installCommunityResource(install: CommunityInstallResolution, options?: InstallCommunitySkillOptions): Promise<CommunityInstalledAnyResource | CommunityMcpInstallPreview | CommunityExecutableLauncherGate>;
+export declare function installCommunityResource(install: CommunityInstallResolution, options?: InstallCommunitySkillOptions & {
+    ownerUserId?: string;
+}): Promise<CommunityInstalledAnyResource | CommunityMcpInstallPreview | CommunityExecutableLauncherGate>;

package/dist/types/cli/core-tools/fork-system-prompt.d.ts

@@ -31,8 +31,6 @@ export interface SubagentSystemPromptInput {
 }
 /** Build the persona section for a built-in fork agent (type + behavioral suffix). */
 export declare function personaForAgentDefinition(agentDef: AgentDefinition): string;
-/** Build the persona section for a team member (name + role + coordination note). */
-export declare function personaForTeamMember(name: string, role: string): string;
 /**
  * Shared subagent context assembly — used by BOTH the in-process fork (agent tool)
  * and the subprocess team member, so their standing context is identical:

package/dist/types/cli/core-tools/registry.d.ts

@@ -3,6 +3,5 @@ import { type CheckpointToolRegistrationDeps } from "./checkpoint-tool-bootstrap
 import { type ConfigToolRegistrationDeps } from "./config-tool-bootstrap.js";
 import { type CronToolRegistrationDeps } from "./cron-tool-bootstrap.js";
 import { type MonitorToolRegistrationDeps } from "./monitor-tool-bootstrap.js";
-import { type TeamToolRegistrationDeps } from "./team-tool-bootstrap.js";
-export type CoreToolSetRegistrationDeps = AgentToolRegistrationDeps & CheckpointToolRegistrationDeps & ConfigToolRegistrationDeps & CronToolRegistrationDeps & MonitorToolRegistrationDeps & Omit<TeamToolRegistrationDeps, "teamRegistry">;
+export type CoreToolSetRegistrationDeps = AgentToolRegistrationDeps & CheckpointToolRegistrationDeps & ConfigToolRegistrationDeps & CronToolRegistrationDeps & MonitorToolRegistrationDeps;
 export declare function registerCoreToolSet(deps: CoreToolSetRegistrationDeps): void;

package/dist/types/cli/core-tools/session-tool-manifest.d.ts

@@ -6,7 +6,5 @@ export interface SessionToolManifestEntry {
     category: CapabilityCategory;
     /** Registered per-session by the runtime bootstrap, not in the static catalog. */
     sessionScoped: true;
-    /** The live registration is deferred (loaded on demand via tool_search). */
-    deferred?: true;
 }
 export declare const SESSION_TOOL_MANIFEST: SessionToolManifestEntry[];

package/dist/types/cli/handlers/community-handler.d.ts

@@ -10,6 +10,10 @@ export interface CommunityHandlerHost {
     resolveCommunityConsentClient?: () => CommunityConsentClient | null;
     resolveCommunityConsentStore?: () => CommunityConsentStore;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+    /** Push a JSON-RPC notification (e.g. pet.asset.updated after a community pet install hydrates the UI store). */
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    /** Active owner id, so community pet install/publish land in the same profile pet.status reads. */
+    memoryUserId?: string;
 }
 export declare const METHOD_CONSENT_REQUIRED_MESSAGE = "Community participation consent is required before publishing shared skills.";
 export declare function handleCommunityGetConsent(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/cli/handlers/goal-handler.d.ts

@@ -0,0 +1,54 @@
+import type { GoalLoopCoordinator } from "../../orchestration/goal-loop-coordinator.js";
+import type { GoalStatus } from "../../orchestration/goal-run-types.js";
+export declare class GoalHandler {
+    private readonly coordinator;
+    private readonly cwd;
+    constructor(coordinator: GoalLoopCoordinator, cwd: string);
+    start(params: {
+        goal: string;
+        cwd?: string;
+        agentPool?: string[];
+    }): Promise<{
+        ok: true;
+        goalRunId: string;
+    }>;
+    status(params: {
+        goalRunId: string;
+    }): Promise<GoalStatus>;
+    message(params: {
+        goalRunId: string;
+        text: string;
+    }): Promise<{
+        ok: true;
+        queued: true;
+    }>;
+    pause(params: {
+        goalRunId: string;
+    }): Promise<{
+        ok: true;
+    }>;
+    resume(params: {
+        goalRunId: string;
+        newGoal?: string;
+    }): Promise<{
+        ok: true;
+    }>;
+    updateGoal(params: {
+        goalRunId: string;
+        newGoal: string;
+    }): Promise<{
+        ok: true;
+    }>;
+    stop(params: {
+        goalRunId: string;
+    }): Promise<{
+        ok: true;
+    }>;
+    events(params: {
+        goalRunId: string;
+        fromSeq?: number;
+        limit?: number;
+    }): Promise<{
+        events: unknown[];
+    }>;
+}

package/dist/types/cli/handlers/pinned-skill-context.d.ts

@@ -1 +1,3 @@
+export declare function extractExplicitSkillMentions(text: string): string[];
+export declare function shouldForceLoadExplicitSkillMentions(text: string): boolean;
 export declare function buildPinnedSkillContext(activeSkills: unknown, log?: (m: string) => void): string;

package/dist/types/cli/handlers/turn-handler.d.ts

@@ -19,7 +19,6 @@ export interface TurnControlHandlerHost {
 }
 export declare function hydrateTurnConfigFromModelMetadata(config: TurnConfig): TurnConfig;
 export declare function hydrateAttachmentReferenceUrlsForTurn(messages: ChatMessage[]): ChatMessage[];
-export declare function activateAttachmentToolsForTurn(toolCatalog: ToolCatalog, messages: ChatMessage[]): string[];
 export declare function getFocusedAttachmentToolNamesForTurn(messages: ChatMessage[]): Set<string> | null;
 type FocusedAttachmentModelPurpose = "imageUnderstanding" | "videoUnderstanding";
 export declare function getFocusedAttachmentUnsupportedContentForTurn(messages: ChatMessage[], purpose: FocusedAttachmentModelPurpose): string | null;

package/dist/types/cli/skill-invocation-service.d.ts

@@ -0,0 +1,8 @@
+export interface RunSkillInvocationParams {
+    skillName: string;
+    skillContent: string;
+    userArgs?: string;
+    skillDir?: string;
+    sessionId?: string;
+}
+export declare function runSkillInvocation(params: RunSkillInvocationParams): Promise<string>;

package/dist/types/cli/{skill-meta-tool-bootstrap.d.ts → skill-tools-bootstrap.d.ts}

@@ -1,30 +1,24 @@
-import type { HookRegistry } from "../contracts/hooks.js";
 import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
 import type { MemoryLearningSink, PathService, ToolCatalog } from "../runtime/ports/index.js";
 import type { WorkspaceSkill } from "../skills/skill-system/skill-types.js";
-import { type SkillSubturnAgent } from "./skill-meta-subturn-service.js";
-export { resolveSkillSubagentTypeForLifecycle } from "./skill-meta-subturn-service.js";
-export interface SkillMetaToolBootstrapDeps {
+export interface SkillToolsBootstrapDeps {
     config: Record<string, unknown>;
     pathService: PathService;
     toolCatalog: ToolCatalog;
 }
 export type SkillLearningMemorySink = MemoryLearningSink;
-export interface SkillMetaToolHost {
+export interface SkillToolsHost {
     getActiveProjectRoot(): string;
     getPluginSkills(): WorkspaceSkill[];
-    getAgent(): SkillSubturnAgent | null;
-    getCurrentSessionId(): string;
-    getCurrentHooks(): HookRegistry | null;
     sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
     getMemoryLearningSink(): SkillLearningMemorySink | null;
     getMemoryUserId(): string;
 }
-export interface SkillMetaToolRegistrationContext extends SkillMetaToolBootstrapDeps {
-    host: SkillMetaToolHost;
+export interface SkillToolsRegistrationContext extends SkillToolsBootstrapDeps {
+    host: SkillToolsHost;
 }
-export declare const skillMetaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<SkillMetaToolRegistrationContext>;
-export declare function configureSkillMetaToolBootstrap(host: SkillMetaToolHost, deps: SkillMetaToolBootstrapDeps): void;
+export declare const skillToolsRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<SkillToolsRegistrationContext>;
+export declare function configureSkillToolsBootstrap(host: SkillToolsHost, deps: SkillToolsBootstrapDeps): void;
 /**
  * Resolve a supporting-file path inside a skill folder.
  * Returns the absolute target, or null when the path escapes the skill dir

package/dist/types/cli/stdio-agent-session-bootstrap.d.ts

@@ -59,7 +59,6 @@ export interface StdioAgentSessionBootstrapDeps {
     setMcpReady(ready: Promise<void>): void;
     setPluginLoader(loader: PluginLoader): void;
     setFileWatcher(watcher: FileWatcher | null): void;
-    getAgent(): Agent | null;
     getAcpPermissionSession(): {
         sessionId: string;
         requestPermission(params: AcpPermissionRequestParams): Promise<{

package/dist/types/cli/tool-bootstrap-core-registration.d.ts

@@ -4,7 +4,7 @@ import { type AskUserQuestion } from "../skills/tools/ask-user-tool.js";
 import { type ExecProgress } from "../skills/tools/exec-tool.js";
 import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
 import type { SandboxConfig } from "../skills/tools/shell/sandbox/sandbox-types.js";
-import { type PathService, type RuntimeToolContract } from "../runtime/ports/index.js";
+import { type PathService } from "../runtime/ports/index.js";
 export interface LocalCoreToolRegistrationContext {
     tools: PortableTool<any>[];
     taskToolHooks?: TaskToolHooks;
@@ -23,14 +23,6 @@ export interface LocalCoreToolRegistrationContext {
         info(message: string): void;
         warn(message: string): void;
     };
-    listToolNames(): string[];
-    findRegisteredTool(name: string): RuntimeToolContract | undefined;
-    activateRegisteredTool(name: string): boolean;
-    listDeferredTools(): Array<{
-        name: string;
-        description: string;
-        searchHint?: string;
-    }>;
 }
 export declare function setGroupSecurityMode(enabled: boolean): void;
 export declare const localCoreToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalCoreToolRegistrationContext>;

package/dist/types/cli/tool-bootstrap.d.ts

@@ -16,8 +16,6 @@ export interface SandboxPermissionSnapshot {
     mode: PermissionMode;
     workdir: string;
     allowedDirs: string[];
-    /** cut7c: current turn is an untrusted community-skill turn → tighten the sandbox. */
-    communityTurn: boolean;
 }
 /** Wire the OS-sandbox permission source (live rule-engine snapshot), or null to clear. */
 export declare function setSandboxPermissionSource(source: (() => SandboxPermissionSnapshot | undefined) | null): void;

package/dist/types/contracts/turn-event.d.ts

@@ -79,7 +79,7 @@ export type TurnEvent = {
     type: "tool_selection_policy";
     turnId: string;
     policyId: string;
-    intent: "benchmark_state_maintenance" | "fresh_evidence" | "verification" | "final_answer" | "deferred_tool_discovery" | "tool_recovery" | "lifecycle_reconciliation";
+    intent: "benchmark_state_maintenance" | "fresh_evidence" | "verification" | "final_answer" | "tool_recovery" | "lifecycle_reconciliation";
     reason: string;
     availableToolNames: string[];
     enabledToolNamesBefore: string[];

package/dist/types/orchestration/agent-instance.d.ts

@@ -84,8 +84,25 @@ export declare class ProductOrchestrator {
     create(params: ProductCreateParams): Promise<string>;
     /** Resume a product from persisted state. */
     resume(productId: string, cwd?: string): Promise<void>;
-    /** Pause a running product. */
-    pause(productId: string): Promise<void>;
+    /**
+     * Pause a running product — the SINGLE pause path (I9).
+     *
+     * `drainTimeoutMs` selects the behavior along ONE mechanism, not separate code paths:
+     *   - `0` (default): instant pause — no drain wait, the loop below force-kills any running
+     *     instances immediately. This is Product's historical hard-kill UX, expressed as a parameter.
+     *   - `> 0`: graceful drain — stop dispatching NEW tasks, then wait up to `drainTimeoutMs` for
+     *     in-flight tasks to settle (inFlightTasks → 0). After a clean drain there is nothing left
+     *     running so the loop kills nothing; on timeout the SAME loop force-kills the stragglers.
+     *
+     * `session.phase` flips to "paused" only AFTER draining, so a run mid-drain is observably still
+     * active (not yet paused).
+     */
+    pause(productId: string, options?: {
+        drainTimeoutMs?: number;
+    }): Promise<void>;
+    /** Poll `session.inFlightTasks` until it settles to 0 or the deadline elapses. The sole drain
+     *  primitive for {@link pause} — there is no other place that waits for tasks to settle. */
+    private waitForInFlightSettle;
     /** Manual checkpoint. */
     checkpoint(productId: string): Promise<void>;
     applyDagMutations(productId: string, mutations: readonly DagMutation[]): void;

package/dist/types/orchestration/delegation-coordinator.d.ts

@@ -0,0 +1,43 @@
+import type { ProductOrchestrator } from "./agent-instance.js";
+export interface DelegationNotify {
+    (method: string, payload: Record<string, unknown>): void;
+}
+export interface DelegationDeps {
+    orchestrator: ProductOrchestrator;
+    cwd: string;
+    notify: DelegationNotify;
+    log?: {
+        info(m: string): void;
+        warn(m: string): void;
+    };
+}
+type DelegationStatus = "running" | "completed" | "failed" | "cancelled";
+export declare class DelegationCoordinator {
+    private readonly deps;
+    private readonly active;
+    constructor(deps: DelegationDeps);
+    /** Active + recent delegations for this project (x/mention.list). */
+    list(): {
+        delegationId: string;
+        agentId: string;
+        brief: string;
+        status: DelegationStatus;
+    }[];
+    /** Cancel a running delegation — aborts the poll loop, which drains+kills the worker. */
+    cancel(delegationId: string): {
+        ok: boolean;
+    };
+    /**
+     * Dispatch ONE ad-hoc task to `agentId` in the background. Returns immediately with the delegationId;
+     * the lifecycle (started / settled) is reported via notify(mention.*). An unready/uninstalled agent
+     * surfaces as a `failed` settle (never a thrown RPC).
+     */
+    delegate(agentId: string, brief: string, opts?: {
+        acceptanceCriteria?: string;
+    }): {
+        delegationId: string;
+    };
+    private run;
+    private settle;
+}
+export {};

package/dist/types/orchestration/goal-acceptance.d.ts

@@ -0,0 +1,20 @@
+import type { AcceptanceChecklist, AcceptanceEvidence, AcceptanceStatus } from "./goal-run-types.js";
+/** Return a NEW checklist with one criterion's status flipped. Never mutates the input.
+ *  Monotonicity contract: a criterion that already `passed` may only revert to `failed` via a
+ *  deterministic verify REGRESSION (allowRegression=true). Any other downgrade of a passed criterion
+ *  (an LLM judge's prose verdict, a re-pending) is IGNORED — `passed` is terminal except when its own
+ *  `verify` command starts failing. This is what makes "no regression goes unnoticed" hold without
+ *  letting assessment flap: real regressions are caught (verify), spurious ones are rejected. */
+export declare function flipCriterionStatus(checklist: AcceptanceChecklist, criterionId: string, status: AcceptanceStatus, evidence?: AcceptanceEvidence[], reason?: string, allowRegression?: boolean): AcceptanceChecklist;
+/** Done iff every criterion is passed or superseded (none pending/failed). */
+export declare function isChecklistDone(checklist: AcceptanceChecklist): boolean;
+/** True iff every not-yet-passed/superseded criterion is covered by an unreachable entry. */
+export declare function unreachableCoversRemaining(checklist: AcceptanceChecklist, unreachable: {
+    criterionId: string;
+    reason: string;
+}[]): boolean;
+/** Derive a new immutable checklist version on goal-edit. Dropped criteria -> superseded. */
+export declare function newChecklistVersion(prev: AcceptanceChecklist, nextCriteria: {
+    id: string;
+    criterion: string;
+}[]): AcceptanceChecklist;

package/dist/types/orchestration/goal-loop-coordinator.d.ts

@@ -0,0 +1,87 @@
+import { type AcceptanceChecklist, type AcceptanceCriterion, type AcceptanceDelta, type GoalQueuedMessage, type PersistedGoalRunState, type PhaseSpec } from "./goal-run-types.js";
+export interface LeaderPort {
+    deriveChecklist(goal: string): Promise<AcceptanceCriterion[]>;
+    planPhase(goal: string, summary: string, drained: GoalQueuedMessage[], checklist: AcceptanceChecklist, agentPool: string[]): Promise<PhaseSpec>;
+    critiquePlan(spec: PhaseSpec, goal: string, checklist: AcceptanceChecklist, agentPool: string[]): Promise<PhaseSpec>;
+    assess(productId: string, checklist: AcceptanceChecklist): Promise<AcceptanceDelta[]>;
+    compact(prevSummary: string, deltas: AcceptanceDelta[]): Promise<string>;
+}
+export interface PhaseRunnerPort {
+    startBoundedProductPhase(spec: PhaseSpec, agentPool: string[], cwd: string, opts: {
+        signal: AbortSignal;
+        onProductId: (productId: string) => void;
+    }): Promise<{
+        productId: string;
+        result: string;
+    }>;
+    resumePhase(productId: string, opts: {
+        signal: AbortSignal;
+        cwd: string;
+        phaseStartMs: number;
+    }): Promise<{
+        result: string;
+    }>;
+}
+export type GoalNotifier = (method: string, payload: Record<string, unknown>) => void;
+export declare class GoalLoopCoordinator {
+    private readonly deps;
+    private seq;
+    private opChain;
+    private activeAbort;
+    constructor(deps: {
+        leader: LeaderPort;
+        runner: PhaseRunnerPort;
+        cwd: string;
+        notify?: GoalNotifier;
+    });
+    private serialize;
+    private append;
+    private persist;
+    /** Launch a goal-run (instant, Codex-style). Returns the goalRunId. */
+    start(goal: string, agentPool: string[]): Promise<string>;
+    private startImpl;
+    /** Load the run; seed `seq` so a fresh instance (post-crash) keeps appending monotonically. */
+    private load;
+    enqueueMessage(goalRunId: string, text: string): Promise<void>;
+    private enqueueMessageImpl;
+    /** Run exactly one phase. Returns the updated state. */
+    runOnePhase(goalRunId: string): Promise<PersistedGoalRunState>;
+    private runOnePhaseImpl;
+    /** B: the single phase tail — assess the in-flight/just-finished Product, flip the checklist, compact
+     *  the summary, append phase_assessed/progress_compacted/phase_boundary, advance phaseIndex, clear the
+     *  in-flight breadcrumb, then run the terminal checks. Called by BOTH the normal path and crash-recovery
+     *  so neither duplicates this logic. Assess throwing propagates to the caller's failure handling. */
+    private finishPhase;
+    /** B (crash-resume): re-attach to a Product that started before a crash. Rebuild it from its persisted
+     *  product-state.json and re-drive it to terminal (runner.resumePhase), then run the SAME phase tail
+     *  (finishPhase). Honest-fail ONLY if resume itself throws — a started phase is recovered, never lost,
+     *  but progress is never fabricated. Bounded by an abort handle so pause() can still drain it. */
+    private recoverCrashedPhase;
+    /** I3: true when the loaded state shows a phase that started (currentProductId set) but never reached
+     *  its assessment/boundary — i.e. a process died mid-phase. Inspects the durable event log because
+     *  the snapshot alone can't distinguish "just started" from "started and crashed". */
+    private crashedMidPhase;
+    /** The ms timestamp of the phase_started event for `productId` (when the crashed phase originally began).
+     *  Used as the crash-resume deliverable-capture window so files created before the crash are kept.
+     *  Returns 0 (no lower bound) if not found — capture-all is acceptable for this rare path. */
+    private phaseStartedMs;
+    /** Drive phases until the run ends or is paused. Not serialized: it only calls the serialized
+     *  runOnePhase in a loop, so a concurrent pause/stop is observed at the next boundary. */
+    runToCompletion(goalRunId: string): Promise<PersistedGoalRunState>;
+    /** Pause: abort the in-flight phase IMMEDIATELY (before serialize) so it drains fast and the mutex
+     *  frees quickly, then persist the paused state. If the in-flight phase is the one being aborted, it
+     *  drains via its abort handler and persists `paused` itself (runOnePhaseImpl's catch); pauseImpl then
+     *  no-ops on the already-paused state. */
+    pause(goalRunId: string): Promise<PersistedGoalRunState>;
+    private pauseImpl;
+    /** Edit the goal (valid only while paused) — derives a new immutable checklist version. */
+    updateGoal(goalRunId: string, newGoal: string): Promise<PersistedGoalRunState>;
+    private updateGoalImpl;
+    /** Resume a paused run; an optional newGoal applies a goal-edit first (reusing updateGoalImpl). */
+    resume(goalRunId: string, newGoal?: string): Promise<PersistedGoalRunState>;
+    private resumeImpl;
+    /** User stop — ends the run as stopped. The caller stops driving the detached loop. */
+    stop(goalRunId: string): Promise<PersistedGoalRunState>;
+    private stopImpl;
+    private end;
+}

package/dist/types/orchestration/goal-mode-adapters.d.ts

@@ -0,0 +1,94 @@
+import type { AgentProcessManager } from "../runtime/infra/agent-process.js";
+import type { AcpDetector } from "../runtime/infra/acp-detector.js";
+import type { ProductOrchestrator } from "./agent-instance.js";
+import type { LeaderPort, PhaseRunnerPort } from "./goal-loop-coordinator.js";
+import { type AcceptanceCriterion, type AcceptanceDelta, type PhaseSpec } from "./goal-run-types.js";
+/**
+ * Deterministic runtime verification — the cc/codex-style "the runner OBSERVES the result" applied to
+ * the judge, run EVERY phase as a continuous regression gate (not a one-time entry ticket). For each
+ * criterion that carries a `verify` shell command (run in the project workspace):
+ *   - FORWARD (pending/failed): exit 0 → a TRUSTED passed delta (bypasses the LLM evidence-gate because
+ *     real exit-0 is harder evidence than any LLM citation — closes the gap where a worker runs a test
+ *     successfully but its distilled summary can't convince a conservative leader).
+ *   - REGRESSION (already passed): re-run it. exit ≠ 0 → a TRUSTED passed→failed regression delta. This
+ *     is what stops a later phase from silently breaking an earlier verified deliverable and the run
+ *     still declaring `done` ("checklist all green, disk actually broken"). A passing re-check is a no-op.
+ * Files accumulate across phases in the same workspace, so without this re-check a regression goes
+ * unnoticed; with it, the strongest deterministic check we have doubles as the regression baseline.
+ */
+export declare function runVerifyDeltas(criteria: AcceptanceCriterion[], cwd: string, log?: {
+    info?(m: string): void;
+    warn?(m: string): void;
+}): Promise<AcceptanceDelta[]>;
+/**
+ * #1 residual regression cover for criteria WITHOUT a `verify` command. Such a criterion passed by citing
+ * an evidence file; if that cited file later VANISHES from the project workspace, the deliverable is
+ * unambiguously gone → emit a TRUSTED passed→failed regression delta. We only flag DELETION (not
+ * modification): a "content contains X" file can be legitimately extended by a later phase, so a content
+ * change is ambiguous, but a missing file is not. Verify-backed criteria are handled by runVerifyDeltas;
+ * "output"-only citations have no on-disk artifact to check and are skipped.
+ */
+export declare function runFileEvidenceRegressionDeltas(criteria: AcceptanceCriterion[], cwd: string, log?: {
+    warn?(m: string): void;
+}): AcceptanceDelta[];
+export declare function recordGoalPhaseChangedFiles(productId: string, cwd: string, phaseStartMs: number): Promise<void>;
+export declare function takeGoalPhaseChangedFiles(productId: string): string[];
+/**
+ * Find the first balanced `{...}` or `[...]` in `text` and JSON.parse it. The leader (an LLM) may
+ * wrap the JSON in prose or a ```json fence; this scans for the first balanced bracket with
+ * string-awareness (braces/brackets inside string values are ignored) so an embedded fence or quote
+ * can't truncate the block. Throws if no balanced JSON is found or it won't parse.
+ */
+export declare function extractJson<T>(text: string): T;
+export interface LeaderAdapterDeps {
+    /** Same transport ProductPlanner.sendToLeader uses (product-planner.ts:579). */
+    processManager: AgentProcessManager;
+    /** Resolves the leader's external ACP descriptor (product-planner.ts:583). */
+    acpDetector: AcpDetector;
+    /** Catalog id of the leader agent (e.g. "qlogicagent"). */
+    leaderAgentId: string;
+    /** Project workspaceDir — the leader process cwd. */
+    cwd: string;
+    /** Live Product engine — assess() reads task outputs/changedFiles via getStatus. */
+    orchestrator: ProductOrchestrator;
+    /** Stable id used as the leader process memberId (one persistent leader per goal-run). */
+    goalRunId: string;
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+export declare function createLeaderAdapter(deps: LeaderAdapterDeps): LeaderPort;
+export interface PhaseRunnerAdapterDeps {
+    /** The live Product engine (same one ProductRunCoordinator.confirmAndStart drives — I3). */
+    orchestrator: ProductOrchestrator;
+    /** Optional per-phase budget passed through to ProductOrchestrator.create. */
+    budget?: {
+        maxTotalTokens?: number;
+        maxDuration?: number;
+    };
+    /** Poll interval (ms) while awaiting phase completion. Default 2000. */
+    pollIntervalMs?: number;
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+export declare function createPhaseRunnerAdapter(deps: PhaseRunnerAdapterDeps): PhaseRunnerPort;
+export declare function parsePhaseSpec(reply: string, availableAgentIds: string[]): PhaseSpec;
+/**
+ * B (evidence-gating): goal-mode's assess() is the SOLE acceptance authority (Product's per-task judge
+ * is a no-op for a session-less goal-mode run), so a criterion may only flip to `passed` when it is
+ * backed by CITED PRIMARY EVIDENCE — not a bare "PASS". This is the pure decision the LLM cannot be
+ * trusted to self-enforce; it's unit-tested independently of the live judge call.
+ *
+ * Rules:
+ *   - `passed` delta: keep only evidence items with a non-empty `source` AND non-empty `quote`, AND
+ *     whose `source` is PRIMARY — i.e. it matches one of the run's actual `changedFiles` (exact or
+ *     basename/suffix match, since the judge may cite a relative path) OR is the literal `"output"`.
+ *     If, after filtering, a passed delta has zero evidence items, DROP it (do not flip) — and log.
+ *   - `failed` / other deltas: kept as-is (their reason is informational; failed needs no evidence).
+ */
+export declare function validateAssessDeltas(rawDeltas: AcceptanceDelta[], changedFiles: string[], log?: {
+    warn(msg: string): void;
+}): AcceptanceDelta[];

package/dist/types/orchestration/goal-run-persistence.d.ts

@@ -0,0 +1,15 @@
+import type { PathService } from "../runtime/ports/index.js";
+import type { GoalRunEvent, PersistedGoalRunState } from "./goal-run-types.js";
+export interface GoalPersistenceOptions {
+    pathService?: PathService;
+}
+export declare function getGoalDir(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): string;
+export declare function getEventsPath(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): string;
+export declare function getSnapshotPath(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): string;
+/** Append one event as a fsync'd JSON line (the durable source of truth). */
+export declare function appendGoalRunEvent(goalRunId: string, event: GoalRunEvent, cwd?: string, o?: GoalPersistenceOptions): Promise<void>;
+export declare function readGoalRunEvents(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): Promise<GoalRunEvent[]>;
+export declare function saveGoalRunSnapshot(state: PersistedGoalRunState, cwd?: string, o?: GoalPersistenceOptions): Promise<void>;
+export declare function loadGoalRunSnapshot(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): Promise<PersistedGoalRunState | undefined>;
+/** Replay the event log into a snapshot (crash recovery). undefined if no goal_started. */
+export declare function rebuildSnapshotFromEvents(goalRunId: string, cwd?: string, o?: GoalPersistenceOptions): Promise<PersistedGoalRunState | undefined>;

package/dist/types/orchestration/goal-run-types.d.ts

@@ -0,0 +1,112 @@
+/** Loop tunables (single source of truth — I9). */
+export declare const GOAL_NO_PROGRESS_LIMIT = 3;
+export declare const GOAL_DRAIN_TIMEOUT_MS: number;
+export declare const GOAL_UNREACHABLE_MIN_STREAK = 2;
+export type GoalRunStatus = "running" | "ended";
+export type GoalPauseState = "running" | "draining" | "paused";
+export type GoalEndReason = "done" | "stopped" | "failed";
+export type AcceptanceStatus = "pending" | "passed" | "failed" | "superseded";
+/** FINAL evidence type (I9 — not staged). source = file path / check name; quote = cited excerpt. */
+export interface AcceptanceEvidence {
+    source: string;
+    quote: string;
+}
+export interface AcceptanceCriterion {
+    id: string;
+    criterion: string;
+    status: AcceptanceStatus;
+    evidence?: AcceptanceEvidence[];
+    reason?: string;
+    verify?: string;
+}
+export interface AcceptanceChecklist {
+    version: number;
+    criteria: AcceptanceCriterion[];
+}
+/** A bounded phase plan (a subset of the Product plan). */
+export interface PhaseSpec {
+    phaseLabel: string;
+    tasks: {
+        taskId: string;
+        assignee: string;
+        prompt: string;
+        dependsOn?: string[];
+        acceptanceCriteria?: string;
+    }[];
+    instances: {
+        name: string;
+        role: string;
+        agentId: string;
+    }[];
+    reasoning?: string;
+    unreachable?: {
+        criterionId: string;
+        reason: string;
+    }[];
+}
+/** Output of assess() — one per criterion the phase touched. */
+export interface AcceptanceDelta {
+    criterionId: string;
+    oldStatus: AcceptanceStatus;
+    newStatus: AcceptanceStatus;
+    evidence?: AcceptanceEvidence[];
+    reasonIfFailed?: string;
+    regression?: boolean;
+}
+export interface GoalQueuedMessage {
+    id: string;
+    ts: string;
+    text: string;
+}
+/** Append-only event (events.jsonl). seq is monotonic from 1. */
+export interface GoalRunEvent {
+    seq: number;
+    ts: string;
+    type: "goal_started" | "phase_planned" | "phase_started" | "task_settled" | "phase_assessed" | "progress_compacted" | "goal_edited" | "message_queued" | "paused" | "resumed" | "stopped" | "phase_boundary" | "ended";
+    payload: Record<string, unknown>;
+}
+/** Derived snapshot (goal-run.json), rebuildable by replaying events. */
+export interface PersistedGoalRunState {
+    goalRunId: string;
+    originalGoal: string;
+    currentGoal: string;
+    goalUpdatedAt?: string;
+    checklistVersion: number;
+    status: GoalRunStatus;
+    pauseState: GoalPauseState;
+    phaseIndex: number;
+    noProgressCount: number;
+    unreachableStreak?: Record<string, number>;
+    progressSummary: string;
+    acceptanceChecklist: AcceptanceChecklist;
+    queuedMessages: GoalQueuedMessage[];
+    agentPool: string[];
+    wallClockStartedAt: string;
+    pausedAt?: string;
+    stopReason?: string;
+    endReason?: GoalEndReason;
+    failedReason?: string;
+    currentProductId?: string;
+    projectWorkspaceDir: string;
+    lastEventSeq: number;
+}
+/** Pull-status shape returned by x/goal.status (GoalStatus, §5.1). */
+export interface GoalStatus {
+    goalRunId: string;
+    status: GoalRunStatus;
+    pauseState: GoalPauseState;
+    goalLabel: string;
+    currentGoal: string;
+    phaseIndex: number;
+    wallClockStartedAt: string;
+    progressSummary: string;
+    acceptance: {
+        passed: number;
+        total: number;
+        criteria: AcceptanceCriterion[];
+    };
+    queuedMessageCount: number;
+    noProgressCount: number;
+    endReason?: GoalEndReason;
+    failedReason?: string;
+}