@autopilot-agent/core 0.1.0 → 0.2.0

package/dist/internal/agent-runtime.d.ts

@@ -20,6 +20,7 @@ import type { CompletionPolicy } from "./kernel/completion-policy";
 import { type ModelBehaviorProfile } from "../runtime/provider/model-behavior-profile";
 import type { McpCapability } from "../runtime/protocol";
 import type { CredentialStore, FileMutationStore } from "../runtime/ports";
+import type { WorkPreviewCapability } from "../runtime/protocol/work-preview-capability";
 import type { JobService } from "../runtime/application/job-service";
 import type { AgentUserQuestionCapability } from "../runtime/application/user-question-service";
 export interface RagCapability {
@@ -42,6 +43,7 @@ export interface AgentOptions {
     workspaceTrusted?: boolean;
     rag?: RagCapability;
     web?: WebCapability;
+    workPreview?: WorkPreviewCapability;
     databaseSearch?: DatabaseSearchCapability;
     focusedPdfFileName?: string;
     focusedResourceId?: string;
@@ -59,7 +61,15 @@ export interface AgentOptions {
         callId: string;
         toolName: string;
         inputHash: string;
+        constraint?: string;
     }) => Promise<boolean>;
+    resolveExternalRestriction?: (request: {
+        workspaceRoot: string;
+        toolName: string;
+        constraint: string;
+    }) => Promise<"allow" | "ask" | "deny">;
+    externalExecutionAuthority?: import("./tools/types").ExternalExecutionAuthority;
+    hostMutationProtection?: import("../runtime/ports/host-mutation-protection").HostMutationProtection;
     context?: AgentContextSnapshot;
     skills?: AgentSkillsCapability;
     inputInbox?: AgentInputInboxCapability;
@@ -113,7 +123,7 @@ export interface AgentCheckpoint {
     stepCount: number;
     messages: AgentMessage[];
     lease?: AgentLease;
-    interruptionReason?: "stale_lease" | "repeated_tool_calls" | "runtime_budget" | "token_budget";
+    interruptionReason?: "stale_lease" | "repeated_tool_calls" | "runtime_budget" | "token_budget" | "write_verification";
     pendingCalls?: AgentToolCall[];
     pendingUserQuestion?: {
         callId: string;
@@ -132,6 +142,7 @@ export interface AgentCheckpoint {
         changedPaths: string[];
         verifiedPaths: string[];
         recoveryAttempts: number;
+        verificationOnly?: boolean;
     };
     fileReadStates?: Array<{
         path: string;
@@ -360,6 +371,7 @@ export type AgentLoopEvent = {
     turnId: string;
     checkpoint: AgentCheckpoint;
     error?: string;
+    errorCode?: string;
     termination?: {
         reason?: AgentTerminationReason;
         budget?: AgentTerminationBudget;

package/dist/internal/kernel/completion-policy.d.ts

@@ -19,6 +19,10 @@ export type CompletionDecision = {
 } | {
     action: "fail";
     reason: string;
+} | {
+    action: "pause";
+    reason: string;
+    message: string;
 };
 export interface CompletionPolicy {
     initialSignal(messages: readonly AgentMessage[]): CompletionIntentSignal;

package/dist/internal/kernel/run-context.d.ts

@@ -30,6 +30,7 @@ export interface ContextCompactionManager {
     }): Promise<AgentCompactionResult>;
 }
 export interface PermissionContext {
+    externalExecutionAuthority?: import("../tools/types").ExternalExecutionAuthority;
     mode: ToolPermissionMode;
     workspaceTrusted?: boolean;
     resolvePersistentGrant?: (request: {
@@ -45,9 +46,16 @@ export interface PermissionContext {
         callId: string;
         toolName: string;
         inputHash: string;
+        constraint?: string;
     }) => Promise<boolean>;
+    resolveExternalRestriction?: (request: {
+        workspaceRoot: string;
+        toolName: string;
+        constraint: string;
+    }) => Promise<"allow" | "ask" | "deny">;
 }
 export interface RunContext {
+    hostMutationProtection?: import("../../runtime/ports/host-mutation-protection").HostMutationProtection;
     capabilityCeiling?: import("../../runtime/domain/product-mode").CapabilityCeiling;
     chat?: import("../tools/chat-tool-runtime").ChatToolRuntime;
     turnId: string;

package/dist/internal/tool-scheduler.d.ts

@@ -10,6 +10,7 @@ export interface ToolSchedulerOptions {
     signal?: AbortSignal;
     maxRetries?: number;
     onProgress?: (callId: string, chunk: string) => void;
+    onResult?: (result: ScheduledToolResult) => void;
 }
 export declare function serializeToolResultForModel(result: ToolExecutionResult): string;
 export declare function createToolScheduler(registry: ToolRegistry, execute: (request: ToolExecutionRequest, options?: ToolExecutionOptions) => Promise<ToolExecutionResult>): {

package/dist/internal/tools/builtins/open-preview-tool.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { AgentToolDefinition } from "../types";
+import type { WorkPreviewCapability, WorkPreviewPrepareResult } from "../../../runtime/protocol/work-preview-capability";
+declare const schema: z.ZodObject<{
+    url: z.ZodString;
+    jobId: z.ZodOptional<z.ZodString>;
+    openWhen: z.ZodOptional<z.ZodEnum<{
+        now: "now";
+        after_turn: "after_turn";
+    }>>;
+}, z.core.$strict>;
+export declare function createOpenPreviewTool(input: {
+    capability: WorkPreviewCapability;
+    workspaceId: string;
+    sessionId: string;
+    turnId: string;
+}): AgentToolDefinition<z.infer<typeof schema>, WorkPreviewPrepareResult>;
+export {};

package/dist/internal/tools/builtins/run-command-tool.d.ts

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import type { AgentToolDefinition } from "../types";
-declare const runCommandSchema: z.ZodObject<{
+export declare const runCommandSchema: z.ZodObject<{
     program: z.ZodString;
     args: z.ZodDefault<z.ZodArray<z.ZodString>>;
     cwd: z.ZodDefault<z.ZodString>;
     timeoutMs: z.ZodDefault<z.ZodNumber>;
+    externalWriteTarget: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare function createRunCommandTool(): AgentToolDefinition<z.infer<typeof runCommandSchema>, Record<string, unknown>>;
-export {};

package/dist/internal/tools/builtins/start-background-job-tool.d.ts

@@ -5,6 +5,15 @@ declare const schema: z.ZodObject<{
     program: z.ZodString;
     args: z.ZodDefault<z.ZodArray<z.ZodString>>;
     cwd: z.ZodDefault<z.ZodString>;
+    externalWriteTarget: z.ZodOptional<z.ZodString>;
+    serviceUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const startBackgroundJobSchema: z.ZodObject<{
+    program: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodDefault<z.ZodString>;
+    externalWriteTarget: z.ZodOptional<z.ZodString>;
+    serviceUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare function createStartBackgroundJobTool(input: {
     jobs: JobService;

package/dist/internal/tools/builtins/todo-write-tool.d.ts

@@ -11,6 +11,20 @@ declare const inputSchema: z.ZodObject<{
             in_progress: "in_progress";
         }>;
     }, z.core.$strict>>;
+    fileTargets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            create: "create";
+            edit: "edit";
+        }>;
+    }, z.core.$strict>>>;
+    externalFileTargets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            create: "create";
+            edit: "edit";
+        }>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 type TodoWriteInput = z.infer<typeof inputSchema>;
 export declare function createTodoWriteTool(): AgentToolDefinition<TodoWriteInput, TodoWriteResult>;

package/dist/internal/tools/mcp-runtime.d.ts

@@ -45,5 +45,10 @@ export declare class McpStdioRuntime {
     private handleLine;
     private failServer;
     private resolveSandboxScope;
+    private isHostExecutionPlatform;
     private releaseSandbox;
 }
+export declare function resolveHostServerCommand(command: string, args: readonly string[]): {
+    executable: string;
+    args: string[];
+};

package/dist/internal/tools/normalized-tool-input.d.ts

@@ -0,0 +1 @@
+export declare function hashNormalizedToolInput(input: unknown): string;

package/dist/internal/tools/permissions/command-policy.d.ts

@@ -13,3 +13,14 @@ export interface CommandPolicyResult {
 export declare const defaultCommandRules: CommandRule[];
 export declare function normalizeProgramName(program: string): string;
 export declare function decideCommandPermission(program: string, args: string[], rules?: CommandRule[]): CommandPolicyResult;
+export declare function resolveCommandAuthorizationIdentity(program: string, platform?: NodeJS.Platform): string;
+export declare const WORKSPACE_COMMAND_CONSTRAINT_PREFIX = "cmd:v2:";
+export declare const LEGACY_WORKSPACE_COMMAND_CONSTRAINT_PREFIX = "cmd:v1:";
+export declare function computeWorkspaceCommandConstraint(input: {
+    workspaceRoot: string;
+    cwd: string;
+    program: string;
+    args: string[];
+    platform?: NodeJS.Platform;
+}): string;
+export declare function isWorkspaceCommandConstraint(value: string | undefined): boolean;

package/dist/internal/tools/permissions/external-execution-policy.d.ts

@@ -0,0 +1,14 @@
+import { type ExternalExecutionAuthorization, type ExternalExecutionTarget, type ExternalWriteCapability } from "../../../runtime/domain/external-execution";
+import type { ToolExecutionContext } from "../types";
+export declare function sealExternalExecutionAuthorization(value: ExternalExecutionAuthorization): ExternalExecutionAuthorization;
+export declare function resolveExternalExecutionTarget(workspaceRoot: string | undefined, input: unknown): Promise<ExternalExecutionTarget | undefined>;
+export declare function externalExecutionTargetLabel(target: ExternalExecutionTarget): string;
+export declare function issueExternalWriteCapability(input: {
+    target: ExternalExecutionTarget;
+    toolName: string;
+    callId: string;
+    inputHash: string;
+    authorization: ExternalExecutionAuthorization;
+}): ExternalWriteCapability;
+export declare function claimExternalWriteCapability(toolName: string, input: unknown, context: ToolExecutionContext): Promise<void>;
+export declare function assertExternalJobDispatch(input: unknown, context: ToolExecutionContext): Promise<void>;

package/dist/internal/tools/permissions/mutation-policy.d.ts

@@ -1,2 +1,9 @@
 import type { ToolExecutionContext } from "../types";
+import type { ResolvedFileTarget } from "./path-access-policy";
+import type { HostMutationProtection } from "../../../runtime/ports/host-mutation-protection";
+export declare function assertHostMutationTargetAllowed(context: {
+    workspaceRoot?: string;
+    hostMutationProtection?: HostMutationProtection;
+}, inputPath: string): Promise<void>;
 export declare function assertFileMutationAllowed(context: ToolExecutionContext): void;
+export declare function assertFileMutationAuthorized(context: Pick<ToolExecutionContext, "fileMutationAuthorization">, target: Pick<ResolvedFileTarget, "isExternal" | "canonicalTarget" | "canonicalWorkspace">, operation: string): void;

package/dist/internal/tools/permissions/path-access-policy.d.ts

@@ -0,0 +1,13 @@
+import type { ToolExecutionContext } from "../types";
+export interface ResolvedFileTarget {
+    absolutePath: string;
+    canonicalWorkspace: string;
+    canonicalTarget: string;
+    isExternal: boolean;
+    exists: boolean;
+    relativePath?: string;
+}
+export declare function resolveFileTarget(workspaceRoot: string | undefined, inputPath: string): Promise<ResolvedFileTarget>;
+export declare function getReadStateKey(target: Pick<ResolvedFileTarget, "isExternal" | "canonicalTarget" | "relativePath">): string;
+export declare function buildExternalConstraint(canonicalTarget: string): string;
+export declare function resolveExternalTargetRestriction(context: Pick<ToolExecutionContext, "resolveExternalRestriction">, target: ResolvedFileTarget, toolName: string): Promise<"allow" | "ask" | "deny">;

package/dist/internal/tools/permissions/workspace-path.d.ts

@@ -3,6 +3,11 @@ export interface WorkspacePath {
     relativePath: string;
     exists: boolean;
 }
+export declare function isInsideRoot(rootPath: string, targetPath: string): boolean;
+export declare function findExistingRealpath(targetPath: string): Promise<{
+    realPath: string;
+    exists: boolean;
+}>;
 export declare function resolveWorkspacePath(workspaceRoot: string | undefined, inputPath: string): Promise<WorkspacePath>;
 export declare function assertRegularFile(targetPath: string): Promise<void>;
 export declare function assertDirectory(targetPath: string): Promise<void>;

package/dist/internal/tools/policy-engine.d.ts

@@ -7,6 +7,7 @@ export interface PolicyEvaluationInput {
     sandbox?: {
         available: boolean;
     };
+    hostExecution?: boolean;
 }
 export declare class PolicyEngine {
     canUsePersistentGrant(context: ToolExecutionContext, facts: ToolActionFacts): boolean;

package/dist/internal/tools/process-utils.d.ts

@@ -3,6 +3,13 @@ export declare class ProcessTreeTerminationError extends Error {
     readonly code: "FAILED" | "TIMEOUT";
     constructor(code: "FAILED" | "TIMEOUT");
 }
+export declare const SANDBOX_START_MAX_ATTEMPTS = 3;
+export declare function isSandboxAvailabilityFailureCode(code: string): boolean;
+export declare class SandboxPrepareExhaustedError extends Error {
+    readonly code: string;
+    readonly diagnostics: readonly string[];
+    constructor(diagnostics: readonly string[]);
+}
 export declare class BoundedOutputBuffer {
     private readonly outputLimit;
     private readonly head;
@@ -33,6 +40,10 @@ export declare function terminateManagedProcessTree(child: ChildProcess, options
     timeoutMs?: number;
 }): Promise<void>;
 export declare function getPlatformExecutable(program: string): string;
+export declare function resolveWindowsPackageManagerCommand(program: string, args: readonly string[]): {
+    executable: string;
+    args: string[];
+} | null;
 export declare function resolveManagedCommand(program: string, args: readonly string[]): {
     executable: string;
     args: string[];

package/dist/internal/tools/sandbox-policy-resolver.d.ts

@@ -1,6 +1,8 @@
 import type { SandboxCapabilityReport, SandboxEnforcement, SandboxMode, SandboxPolicy } from "../../runtime/domain/sandbox-policy";
 import type { ToolPermissionMode } from "./types";
+import type { ExternalWriteCapability } from "../../runtime/domain/external-execution";
 export interface SandboxResolverInput {
+    externalWriteCapability?: ExternalWriteCapability;
     mode: SandboxMode;
     workspaceRoot?: string;
     tempRoot?: string;

package/dist/internal/tools/tool-executor.d.ts

@@ -10,6 +10,7 @@ export declare class ToolExecutor {
         status: "error";
     }> | undefined>;
     execute(request: ToolExecutionRequest, options?: ToolExecutionOptions): Promise<ToolExecutionResult>;
-    private resolveSandboxScope;
+    private resolveSandboxProbe;
     private consumeApproval;
+    private assertLatestExternalRestrictionAllowed;
 }

package/dist/internal/tools/types.d.ts

@@ -3,15 +3,37 @@ import type { VisionAnalyzer } from "../../runtime/provider/vision-analyzer";
 import type { FileMutationStore, SandboxPort } from "../../runtime/ports";
 import type { SandboxMode, SandboxPolicy } from "../../runtime/domain/sandbox-policy";
 import type { UserQuestionRequest } from "../../runtime/domain";
+import type { ExternalExecutionAuthorization, ExternalExecutionTarget } from "../../runtime/domain/external-execution";
+export interface ExternalExecutionAuthority {
+    freeze(input: {
+        approval: ToolApprovalRequest;
+        input: unknown;
+    }): Promise<void>;
+    authorize(input: {
+        toolName: string;
+        input: unknown;
+        callId: string;
+        inputHash: string;
+        constraint: string;
+        approval?: {
+            approvalId: string;
+            decision: ToolApprovalDecision;
+        };
+    }): Promise<ExternalExecutionAuthorization | null>;
+}
 export interface SandboxExecutionBinding {
     port: SandboxPort;
     mode: SandboxMode;
     tempRoot?: string;
 }
-export interface SandboxExecutionScope {
+export type SandboxExecutionScope = {
+    execution?: "sandboxed";
     port: SandboxPort;
     policy: SandboxPolicy;
-}
+} | {
+    execution: "host";
+    policy: SandboxPolicy;
+};
 export type ToolPermissionDecision = "allow" | "approval_required" | "deny";
 export type ToolApprovalDecision = "allow_once" | "allow_session" | "allow_workspace" | "deny";
 export type ToolPermissionMode = "ask" | "auto_approve" | "full_access";
@@ -89,6 +111,15 @@ export type ToolDisplayDetail = {
     host: string;
     contentType: string;
     truncated: boolean;
+} | {
+    kind: "open_preview";
+    previewId: string;
+    hostLabel: string;
+    copyUrl: string;
+    openWhen: import("../../runtime/protocol/work-preview-capability").WorkPreviewOpenWhen;
+    state: "prepared";
+    jobId?: string;
+    autoOpen?: boolean;
 };
 export interface ToolJobDisplayFacts {
     action: "start" | "list" | "read" | "stop";
@@ -113,6 +144,8 @@ export interface ToolDisplayFacts {
         removed?: number;
         truncated?: boolean;
     };
+    executionMode?: "sandboxed" | "unisolated" | "unavailable";
+    diagnostics?: string[];
 }
 export interface ApprovalDisplayFacts {
     operation: string;
@@ -121,6 +154,10 @@ export interface ApprovalDisplayFacts {
     resource?: string;
     risk?: string;
     actionPreview?: string;
+    cwd?: string;
+    unknownScope?: boolean;
+    executionMode?: ToolDisplayFacts["executionMode"];
+    hostExecution?: true;
     allowedDecisions: ToolApprovalDecision[];
 }
 export interface ToolApprovalRequest {
@@ -134,6 +171,7 @@ export interface ToolApprovalRequest {
     preview: Record<string, unknown>;
     expiresAt: string;
     allowedDecisions?: ToolApprovalDecision[];
+    taskFileSet?: import("../../runtime/domain/approval").TaskFileTarget[];
     display?: ApprovalDisplayFacts;
 }
 export interface ToolExecutionRequest {
@@ -205,10 +243,19 @@ export interface ToolActionFacts {
     stableConstraint?: string;
     hardDenyReason?: string;
     requiresApproval?: boolean;
+    externalMutation?: boolean;
+    externalTarget?: {
+        canonicalTarget: string;
+        canonicalWorkspace: string;
+    };
+    externalRestriction?: "allow" | "ask" | "deny";
+    externalExecutionTarget?: ExternalExecutionTarget;
     approval?: {
         reason: string;
         preview?: Record<string, unknown>;
     };
+    taskFileSet?: import("../../runtime/domain/approval").TaskFileTarget[];
+    commandCwd?: string;
 }
 export interface ToolPolicyResult {
     decision: ToolPermissionDecision;
@@ -233,6 +280,10 @@ export interface ToolEvent {
     errorCode?: string;
 }
 export interface ToolExecutionContext {
+    hostMutationProtection?: import("../../runtime/ports/host-mutation-protection").HostMutationProtection;
+    executionSessionId?: string;
+    externalExecutionAuthority?: ExternalExecutionAuthority;
+    sandboxExecutionOverride?: "direct";
     capabilityCeiling?: import("../../runtime/domain/product-mode").CapabilityCeiling;
     workspaceRoot?: string;
     permissionMode: ToolPermissionMode;
@@ -279,7 +330,19 @@ export interface ToolExecutionContext {
         callId: string;
         toolName: string;
         inputHash: string;
+        constraint?: string;
     }) => Promise<boolean>;
+    resolveExternalRestriction?: (request: {
+        workspaceRoot: string;
+        toolName: string;
+        constraint: string;
+    }) => Promise<"allow" | "ask" | "deny">;
+    fileMutationAuthorization?: {
+        canonicalTarget: string;
+        canonicalWorkspace: string;
+        operation: string;
+        constraint: string;
+    };
     visionAnalyzer?: VisionAnalyzer;
     allowedTools?: string[];
     sandbox?: SandboxExecutionBinding;
@@ -311,6 +374,7 @@ export interface AgentToolDefinition<TInput, TOutput> {
     createActionFacts(input: TInput, context: ToolExecutionContext): ToolActionFacts | Promise<ToolActionFacts>;
     execute(input: TInput, context: ToolExecutionContext): Promise<TOutput>;
     serializeOutput(output: TOutput): unknown;
+    projectDisplayDetail?(output: TOutput): ToolDisplayDetail | undefined;
     createExecutionResult?(input: TInput, output: TOutput, context: {
         callId: string;
         toolName: string;

package/dist/runtime/adapters/memory/memory-approval-store.d.ts

@@ -1,8 +1,40 @@
 import type { ApprovalStore, GetApprovalDecisionInput, GetPersistentGrantInput } from "../../ports/approval-store";
 import type { ApprovalDecision, PersistentGrant } from "../../domain/approval";
+import type { ExternalExecutionApproval } from "../../domain/external-execution";
+import type { ExternalFileApproval } from "../../domain/external-permissions";
+import type { SandboxDegradeApproval } from "../../domain/sandbox-policy";
 export declare class MemoryApprovalStore implements ApprovalStore {
     private decisions;
     private grants;
+    private executionApprovals;
+    private consumedExecutions;
+    private fileApprovals;
+    private consumedFiles;
+    private degradeApprovals;
+    private consumedDegrades;
+    saveExecutionApproval(request: ExternalExecutionApproval): Promise<boolean>;
+    getExecutionApproval(input: GetApprovalDecisionInput): Promise<ExternalExecutionApproval | null>;
+    consumeExecutionApproval(input: GetApprovalDecisionInput & {
+        constraint: string;
+        callId: string;
+        normalizedInputHash: string;
+        now: string;
+    }): Promise<boolean>;
+    saveFileApproval(request: ExternalFileApproval): Promise<boolean>;
+    getFileApproval(input: GetApprovalDecisionInput): Promise<ExternalFileApproval | null>;
+    consumeFileApproval(input: GetApprovalDecisionInput & {
+        constraint: string;
+        callId: string;
+        normalizedInputHash: string;
+        now: string;
+    }): Promise<boolean>;
+    saveDegradeApproval(request: SandboxDegradeApproval): Promise<boolean>;
+    consumeDegradeApproval(input: GetApprovalDecisionInput & {
+        constraint: string;
+        callId: string;
+        normalizedInputHash: string;
+        now: string;
+    }): Promise<boolean>;
     getDecision(input: GetApprovalDecisionInput): Promise<ApprovalDecision | null>;
     saveDecision(decision: ApprovalDecision): Promise<boolean>;
     getPersistentGrant(input: GetPersistentGrantInput): Promise<PersistentGrant | null>;
@@ -11,6 +43,13 @@ export declare class MemoryApprovalStore implements ApprovalStore {
     }): Promise<PersistentGrant>;
     deletePersistentGrant(input: GetPersistentGrantInput): Promise<boolean>;
     deleteBySession(sessionId: string): Promise<void>;
+    listPersistentGrants(input: {
+        workspaceRoot?: string;
+        sessionId?: string;
+    }): Promise<PersistentGrant[]>;
+    setGrantProjection(input: GetPersistentGrantInput & {
+        projection: "synced" | "pending";
+    }): Promise<PersistentGrant | null>;
     private decisionKey;
     private grantKey;
 }

package/dist/runtime/adapters/memory/memory-file-mutation-store.d.ts

@@ -12,5 +12,5 @@ export declare class MemoryFileMutationStore implements FileMutationStore {
     saveUndoTransaction(transaction: UndoTransaction): Promise<void>;
     listUndoTransactions(sessionId: string): Promise<UndoTransaction[]>;
     deleteBySession(sessionId: string): Promise<void>;
-    withWorkspaceLock<T>(_workspaceRoot: string, operation: () => Promise<T>): Promise<T>;
+    withWorkspaceLock<T>(_workspaceRoot: string, operation: () => Promise<T>, canonicalTargets?: readonly string[]): Promise<T>;
 }

package/dist/runtime/application/approval-service.d.ts

@@ -1,11 +1,18 @@
-import type { ApprovalStore, CheckpointStore, Clock, TranscriptStore, TurnStore } from "../ports";
-import type { ApprovalDecision, SubmitApprovalInput } from "../domain/approval";
+import type { ApprovalStore, CheckpointStore, Clock, ExternalPermissionProjector, TranscriptStore, TurnStore } from "../ports";
+import { type ApprovalDecision, type PersistentGrant, type SubmitApprovalInput } from "../domain/approval";
+import { type ExternalExecutionAuthorization } from "../domain/external-execution";
+import type { ExternalExecutionAuthority } from "../../internal/tools/types";
 export interface ApprovalServiceDependencies {
     approvalStore: ApprovalStore;
     checkpointStore: CheckpointStore;
     transcriptStore: TranscriptStore;
     turnStore: TurnStore;
     clock: Clock;
+    externalRuleProjector?: ExternalPermissionProjector;
+}
+export interface RevokePersistentGrantResult {
+    deleted: boolean;
+    ruleRemoved: boolean;
 }
 export interface ApprovalService {
     submit(input: SubmitApprovalInput): Promise<ApprovalDecision>;
@@ -20,5 +27,64 @@ export interface ApprovalService {
         toolName: string;
         constraint: string;
     }): Promise<boolean>;
+    listPersistentGrants(input?: {
+        workspaceRoot?: string;
+        sessionId?: string;
+    }): Promise<PersistentGrant[]>;
+    revokePersistentGrant(input: {
+        workspaceRoot: string;
+        sessionId: string;
+        toolName: string;
+        constraint: string;
+    }): Promise<RevokePersistentGrantResult>;
+}
+export interface InternalApprovalService extends ApprovalService {
+    freezeExecutionApproval(input: {
+        sessionId: string;
+        turnId: string;
+        workspaceRoot: string;
+    } & Parameters<ExternalExecutionAuthority["freeze"]>[0]): Promise<void>;
+    authorizeExecution(input: {
+        sessionId: string;
+        turnId: string;
+        workspaceRoot: string;
+    } & Parameters<ExternalExecutionAuthority["authorize"]>[0]): Promise<ExternalExecutionAuthorization | null>;
+    resolveExternalRestriction(input: {
+        workspaceRoot: string;
+        toolName: string;
+        constraint: string;
+    }): Promise<"allow" | "ask" | "deny">;
+    consumeFileApproval(input: {
+        sessionId: string;
+        turnId: string;
+        approvalId: string;
+        constraint: string;
+        callId: string;
+        normalizedInputHash: string;
+        now: string;
+    }): Promise<boolean>;
+    consumeDegradeApproval(input: {
+        sessionId: string;
+        turnId: string;
+        approvalId: string;
+        constraint: string;
+        callId: string;
+        normalizedInputHash: string;
+        now: string;
+    }): Promise<boolean>;
+    hasTaskFileSetGrant(input: {
+        sessionId: string;
+        turnId: string;
+        workspaceRoot: string;
+        path: string;
+        operation: "create" | "edit";
+    }): Promise<boolean>;
+    hasExternalTaskFileSetGrant(input: {
+        sessionId: string;
+        turnId: string;
+        workspaceRoot: string;
+        canonicalTarget: string;
+        operation: "create" | "edit";
+    }): Promise<boolean>;
 }
-export declare function createApprovalService(dependencies: ApprovalServiceDependencies): ApprovalService;
+export declare function createApprovalService(dependencies: ApprovalServiceDependencies): InternalApprovalService;

package/dist/runtime/application/job-execution-facts.d.ts

@@ -0,0 +1,2 @@
+import type { JobExecutionFacts } from "../domain/job";
+export declare function projectJobCloseFacts(stderr: string, signal?: NodeJS.Signals | null): JobExecutionFacts;

package/dist/runtime/application/job-service-ownership.d.ts

@@ -0,0 +1,5 @@
+export interface JobServiceOwnershipProbe {
+    listenerPids(port: number): Promise<readonly number[] | undefined>;
+    ancestry(pid: number): Promise<readonly number[] | undefined>;
+}
+export declare function createDefaultJobServiceOwnershipProbe(): JobServiceOwnershipProbe;