sdd-agent-platform 0.1.0 → 0.3.0

package/dist/packages/core/src/index.d.ts

@@ -20,6 +20,39 @@ export declare const BACKGROUND_EXECUTOR_CONTRACT_VERSION = "phase-3.11-backgrou
 export declare const WAVE_EXECUTOR_CONTRACT_VERSION = "phase-3.12-wave-executor-v1";
 export declare const LOCAL_RUN_INDEX_CONTRACT_VERSION = "phase-3.13-local-run-index-v1";
 export declare const GOVERNANCE_POLICY_CONTRACT_VERSION = "phase-3.14-governance-policy-v1";
+export declare const CONTEXT_RESOLVER_CONTRACT_VERSION = "phase-5.1-context-resolver-v1";
+export declare const LIFECYCLE_RISK_GATE_CONTRACT_VERSION = "phase-5.1-lifecycle-risk-gate-v1";
+export declare const OUTPUT_QUALITY_CONTRACT_VERSION = "phase-5.1-output-quality-v1";
+export declare const WORKFLOW_GATE_CONTRACT_VERSION = "phase-5.2-workflow-gate-v1";
+export declare const AGENT_REGISTRY_CONTRACT_VERSION = "phase-5.2-agent-registry-v1";
+export declare const TASK_GRAPH_CONTRACT_VERSION = "phase-5.3-task-graph-v1";
+export declare const TASK_RUN_EVIDENCE_CONTRACT_VERSION = "phase-5.3-task-run-evidence-v1";
+export declare const QUERY_STATUS_CONTRACT_VERSION = "phase-5.4-query-status-v1";
+export declare const SKILL_AGENT_EVAL_CONTRACT_VERSION = "phase-5.5-skill-agent-eval-v1";
+export declare const HARNESS_LEARNING_CONTRACT_VERSION = "phase-5.5-harness-learning-v1";
+export declare const PROJECT_CONTEXT_PACK_CONTRACT_VERSION = "phase-5.5-project-context-pack-v1";
+export declare const AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION = "phase-6.0-agent-skill-team-runtime-v1";
+export declare const CAPABILITY_SOURCE_CATALOG_VERSION = "phase-6.0-capability-source-catalog-v1";
+export declare const EXTERNAL_AGENT_PACK_IMPORT_POLICY_VERSION = "phase-6.0-external-agent-pack-import-policy-v1";
+export declare const TOOL_PERMISSION_SPEC_VERSION = "phase-6.0-tool-permission-spec-v1";
+export declare const HOST_ADAPTER_CONTRACT_VERSION = "phase-6.0-host-adapter-contract-v1";
+export declare const AGENT_ROUTER_CONTRACT_VERSION = "phase-6.0-agent-router-v1";
+export declare const TEAM_MODE_POLICY_VERSION = "phase-6.0-team-mode-policy-v1";
+export declare const EVIDENCE_INGESTION_CONTRACT_VERSION = "phase-6.0-evidence-ingestion-v1";
+export declare const AGENT_EXECUTION_RECORD_CONTRACT_VERSION = "phase-6.0-agent-execution-record-v1";
+export declare const TEAM_SESSION_RECORD_CONTRACT_VERSION = "phase-6.0-team-session-record-v1";
+export declare const RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION = "phase-6.1-resident-worker-runtime-v1";
+export declare const SDD_EVIDENCE_CONTRACT = "sdd-evidence-v1";
+export declare const SDD_EVIDENCE_VERSION = "1.0.0";
+export declare const ACCEPTANCE_POLICY_RULESET_VERSION = "acceptance-policy-v1";
+export declare const INVOCATION_LEDGER_CONTRACT_VERSION = "phase-6.9-invocation-ledger-v1";
+export declare const ROUTE_CACHE_CONTRACT_VERSION = "phase-6.9-route-cache-v1";
+export declare const RUNTIME_PROFILE_CONTRACT_VERSION = "phase-6.9-runtime-profile-v1";
+export declare const CONTEXT_BUDGET_CONTRACT_VERSION = "phase-6.10-context-budget-v1";
+export declare const COMMAND_OUTPUT_SUMMARY_CONTRACT_VERSION = "sdd-command-output-summary-v1";
+export declare const EVIDENCE_SUMMARY_CONTRACT_VERSION = "sdd-evidence-summary-v1";
+export declare const CONTEXT_PACKAGE_CONTRACT_VERSION = "sdd-context-package-v1";
+export declare const LOG_WORKER_SUMMARY_CONTRACT_VERSION = "sdd-log-worker-summary-v1";
 export type DoctorLevel = 'PASS' | 'WARN' | 'FAIL';
 export type RunStatus = 'created' | 'running' | 'completed' | 'blocked' | 'failed' | 'archived';
 export type LifecycleProfile = 'direct' | 'compact' | 'full' | 'research';
@@ -28,7 +61,14 @@ export type SddResultStatus = 'PASS' | 'PASS_WITH_GAPS' | 'FAIL' | 'BLOCKED' | '
 export type DelegationRunMode = 'foreground' | 'background';
 export type DelegationStatus = 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'CANCELLED' | 'RECOVERABLE' | 'STALE';
 export type GoalVerifyStatus = 'PASS' | 'PASS_WITH_GAPS' | 'FAIL' | 'BLOCKED';
+export type HarnessVerifyStatus = 'PASS' | 'GAPS' | 'BLOCKED' | 'HUMAN_NEEDED';
 export type ArtifactResultIngestionStatus = 'accepted' | 'rejected';
+export type EvidenceCoverageStatus = 'PASS' | 'FAIL' | 'BLOCKED' | 'REFERENCED_ONLY' | 'MISSING';
+export type EvidenceQualityIssue = 'EMPTY_EVIDENCE' | 'TODO_PLACEHOLDER' | 'TEMPLATE_TEXT' | 'MENTION_ONLY' | 'UNSOURCED_PASS' | 'MISSING_COMMAND_OUTPUT' | 'MISSING_ARTIFACT_REFERENCE' | 'MISSING_MATERIAL_REFERENCE' | 'PROVENANCE_GAP' | 'POLICY_RULE_FAILED' | 'DERIVED_SOURCE_EVIDENCE' | 'PARTITION_SCOPE_VIOLATION';
+export type ContextProfile = 'brief' | 'normal' | 'forensic';
+export type ContextBuildMode = 'do' | 'verify' | 'sync-back' | 'doctor';
+export type ContextSourceKind = 'artifact' | 'run_state' | 'ledger' | 'document' | 'command_output' | 'derived';
+export type ContextSummaryStatus = 'PASS' | 'FAIL' | 'BLOCKED' | 'UNKNOWN';
 export type DetectionConfidence = 'high' | 'medium' | 'low';
 export interface DetectionEvidence {
     kind: string;
@@ -68,6 +108,7 @@ export interface ProjectConfig {
     };
     sdd: {
         spec_dir: string;
+        default_branch?: string;
         docs_language: string;
         compatible_with: string;
     };
@@ -87,6 +128,7 @@ export interface ProjectConfig {
         decision_required: boolean;
         profiles: LifecycleProfile[];
     };
+    agentRuntime?: ProjectAgentRuntimeConfig;
 }
 export type ToolCapabilityCategory = 'runtime' | 'editing' | 'git' | 'validation' | 'browser' | 'artifact' | 'governance';
 export type ToolCapabilitySideEffect = 'read_only' | 'local_write' | 'command_execution' | 'external_interaction';
@@ -303,6 +345,38 @@ export type ImpactConfidence = 'high' | 'medium' | 'low';
 export type ValidationClarity = 'clear' | 'partial' | 'unclear';
 export type OrchestrationUncertainty = 'low' | 'medium' | 'high';
 export type Reversibility = 'reversible' | 'irreversible' | 'unknown';
+export type ContextBranchSource = 'explicit_option' | 'cli_option' | 'project_config' | 'git_branch';
+export interface ContextResolverContract {
+    contract: typeof CONTEXT_RESOLVER_CONTRACT_VERSION;
+    branch: string;
+    partition: string;
+    rawBranch: string;
+    branchSource: ContextBranchSource;
+    currentGitBranch: string | null;
+    workingTreeMatched: boolean | null;
+    specDir: string;
+}
+export type LifecycleRiskCategory = 'state_machine' | 'concurrency' | 'database_data_loss' | 'security' | 'sql' | 'api_schema' | 'ci_build' | 'external_unknown';
+export type LifecycleRiskExtractionSource = 'from_text' | 'from_file' | 'none';
+export interface LifecycleRiskExtractionEvidence {
+    category: LifecycleRiskCategory;
+    matched: string;
+    riskTag: string;
+}
+export interface LifecycleRiskGateExtraction {
+    contract: typeof LIFECYCLE_RISK_GATE_CONTRACT_VERSION;
+    source: LifecycleRiskExtractionSource;
+    riskTags: string[];
+    affectedContracts: string[];
+    externalUnknown: boolean;
+    architectureDecisionRequired: boolean;
+    reversibility?: Reversibility;
+    validationClarity?: ValidationClarity;
+    impactConfidence?: ImpactConfidence;
+    evidence: LifecycleRiskExtractionEvidence[];
+    signals: Partial<LifecycleDecisionSignals>;
+}
+export type LifecycleAutonomyCeiling = 'direct_execution_allowed' | 'compact_boundary_only' | 'full_sdd_with_checkpoint' | 'research_before_implementation';
 export interface LifecycleDecisionSignals {
     intent_clarity: SignalClarity;
     acceptance_clarity: SignalClarity;
@@ -336,6 +410,7 @@ export interface LifecycleDecisionGateResult {
     record: LifecycleDecisionRecord;
     checkpointRequired: boolean;
     boundaries: string[];
+    autonomyCeiling: LifecycleAutonomyCeiling;
 }
 export interface ArtifactIndexEntry {
     path: string;
@@ -344,6 +419,13 @@ export interface ArtifactIndexEntry {
     agent: string | null;
     createdAt: string;
 }
+export interface RunDocumentSnapshot {
+    specHash: string | null;
+    planHash: string | null;
+    tasksHash: string | null;
+    planBasedOnSpecHash: string | null;
+    tasksBasedOnPlanHash: string | null;
+}
 export interface RunState {
     contract: typeof RUN_STATE_CONTRACT;
     runtimeVersion: typeof RUNTIME_VERSION;
@@ -351,6 +433,11 @@ export interface RunState {
     status: RunStatus;
     phase: string | null;
     currentTask: string | null;
+    partition: string | null;
+    gitBranch: string | null;
+    taskId: string | null;
+    affectedFiles: string[];
+    documentSnapshot: RunDocumentSnapshot;
     createdAt: string;
     updatedAt: string;
     projectRoot: string;
@@ -372,6 +459,8 @@ export interface RunState {
     syncBack: {
         mode: 'proposal';
         proposalPath: string | null;
+        proposalDigest?: string | null;
+        sourceVerifyStatus?: GoalVerifyStatus | SingleTaskLoopStatus | null;
         status: 'not_created' | 'proposed' | 'applied';
     };
 }
@@ -411,6 +500,15 @@ export interface SddTask {
     affectedFiles: string[];
     validation: string[];
     risk: string[];
+    acceptanceRefs: string[];
+    planRefs: string[];
+    fileOwnership: string[];
+    agentFit: string[];
+    verificationAvailability: string[];
+    autonomy: string | null;
+    allowedAgents: string[];
+    requiredArtifacts: string[];
+    gapState: string | null;
     boundary: string | null;
     acceptance: string[];
     implementationNotes: string | null;
@@ -434,6 +532,13 @@ export interface SddTaskModel {
         specExists: boolean;
         planExists: boolean;
         tasksExists: boolean;
+        specHash?: string | null;
+        planHash?: string | null;
+        tasksHash?: string | null;
+        planBasedOnSpecHash?: string | null;
+        tasksBasedOnPlanHash?: string | null;
+        planStale?: boolean;
+        tasksStale?: boolean;
     };
     tasks: SddTask[];
     gaps: SddTaskGap[];
@@ -448,6 +553,15 @@ export interface TaskGraphNode {
     affectedFiles: string[];
     risk: string[];
     validation: string[];
+    acceptanceRefs: string[];
+    planRefs: string[];
+    fileOwnership: string[];
+    agentFit: string[];
+    verificationAvailability: string[];
+    autonomy: string | null;
+    allowedAgents: string[];
+    requiredArtifacts: string[];
+    gapState: string | null;
     source: SddTaskSourceLocation;
 }
 export interface TaskGraphEdge {
@@ -464,6 +578,7 @@ export interface TaskGraphDiagnostic {
     recommendation: string;
 }
 export interface TaskGraphPlan {
+    contract: typeof TASK_GRAPH_CONTRACT_VERSION;
     version: typeof TASK_GRAPH_PLANNER_CONTRACT_VERSION;
     branch: string;
     valid: boolean;
@@ -543,6 +658,90 @@ export interface BackgroundExecutorInspection {
     valid: boolean;
     issues: ContractValidationIssue[];
 }
+export type ResidentWorkerRuntimeStatus = 'claimed' | 'active' | 'stale' | 'terminal' | 'blocked';
+export interface ResidentWorkerRuntimeRecord {
+    version: typeof RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION;
+    runtimeId: string;
+    runId: string;
+    taskId: string;
+    agent: string;
+    workerAdapterId: string;
+    delegationId: string;
+    queueItemId: string;
+    expectedArtifact: string;
+    status: ResidentWorkerRuntimeStatus;
+    claimedAt: string;
+    lastHeartbeatAt: string | null;
+    leaseSeconds: number;
+    leaseExpiresAt: string;
+    updatedAt: string;
+    evidenceSummary: string;
+}
+export interface ResidentWorkerRuntimeClaimOptions {
+    branch?: string;
+    runId?: string;
+    taskId: string;
+    runtimeId?: string;
+    agent?: string;
+    workerAdapterId?: string;
+    delegationId?: string;
+    leaseSeconds?: number;
+}
+export interface ResidentWorkerRuntimeClaimResult {
+    version: typeof RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION;
+    runId: string;
+    runtimeId: string | null;
+    taskId: string;
+    agent: string;
+    workerAdapterId: string;
+    delegationId: string | null;
+    queueItemId: string | null;
+    expectedArtifact: string | null;
+    status: ResidentWorkerRuntimeStatus;
+    leaseExpiresAt: string | null;
+    runtime: ResidentWorkerRuntimeRecord | null;
+    issues: ContractValidationIssue[];
+    message: string;
+}
+export interface ResidentWorkerRuntimeHeartbeatOptions {
+    runId: string;
+    runtimeId: string;
+    leaseSeconds?: number;
+}
+export interface ResidentWorkerRuntimeHeartbeatResult {
+    version: typeof RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION;
+    runId: string;
+    runtimeId: string;
+    status: ResidentWorkerRuntimeStatus;
+    leaseExpiresAt: string | null;
+    runtime: ResidentWorkerRuntimeRecord | null;
+    issues: ContractValidationIssue[];
+    message: string;
+}
+export interface ResidentWorkerRuntimeInspection {
+    version: typeof RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION;
+    runId: string;
+    runtimeId: string;
+    runtime: ResidentWorkerRuntimeRecord | null;
+    queueItem: DelegationQueueItem | null;
+    workerAdapter: WorkerAdapterContract | null;
+    status: ResidentWorkerRuntimeStatus;
+    leaseExpired: boolean;
+    valid: boolean;
+    issues: ContractValidationIssue[];
+    recommendedNextCommand: string;
+}
+export interface ResidentWorkerRuntimeList {
+    version: typeof RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION;
+    runId: string;
+    runtimes: ResidentWorkerRuntimeRecord[];
+    activeRuntimes: number;
+    staleRuntimes: number;
+    terminalRuntimes: number;
+    blockedRuntimes: number;
+    valid: boolean;
+    issues: ContractValidationIssue[];
+}
 export type WaveExecutorStrategy = 'fast-stop' | 'safe-continue';
 export type WaveExecutorStatus = 'claimed' | 'completed' | 'failed' | 'blocked';
 export interface WaveExecutorRunOptions {
@@ -626,6 +825,420 @@ export interface GovernancePolicyDecision {
     issues: ContractValidationIssue[];
     policy: GovernancePolicy;
 }
+export type WorkflowGateId = 'spec' | 'plan' | 'tasks' | 'do' | 'verify' | 'doctor';
+export interface WorkflowGateContract {
+    version: typeof WORKFLOW_GATE_CONTRACT_VERSION;
+    id: WorkflowGateId;
+    command: string;
+    requiredInputs: string[];
+    allowedAgents: string[];
+    requiredArtifacts: string[];
+    gateConditions: string[];
+    gapClosureBehavior: string;
+    nextAction: string;
+}
+export interface WorkflowGateRegistry {
+    version: typeof WORKFLOW_GATE_CONTRACT_VERSION;
+    workflows: WorkflowGateContract[];
+}
+export interface WorkflowGateValidation {
+    version: typeof WORKFLOW_GATE_CONTRACT_VERSION;
+    valid: boolean;
+    workflows: WorkflowGateContract[];
+    issues: ContractValidationIssue[];
+}
+export type AgentAutonomyCeiling = 'read_only' | 'foreground_write' | 'validation_only' | 'review_only';
+export interface AgentRegistryEntry {
+    version: typeof AGENT_REGISTRY_CONTRACT_VERSION;
+    id: string;
+    role: string;
+    allowedStages: string[];
+    capabilities: string[];
+    readBoundary: string[];
+    writeBoundary: string[];
+    toolAllowlist: string[];
+    requiredArtifact: string;
+    verificationExpectation: string;
+    autonomyCeiling: AgentAutonomyCeiling;
+    stopCondition: string;
+}
+export interface AgentRegistry {
+    version: typeof AGENT_REGISTRY_CONTRACT_VERSION;
+    agents: AgentRegistryEntry[];
+}
+export interface AgentRegistryValidation {
+    version: typeof AGENT_REGISTRY_CONTRACT_VERSION;
+    valid: boolean;
+    agents: AgentRegistryEntry[];
+    issues: ContractValidationIssue[];
+}
+export type BuiltInAgentProfileId = 'planner' | 'architect' | 'implementer' | 'reviewer' | 'validator' | 'researcher' | 'orchestrator' | 'security' | 'domain_expert';
+export type AgentProfileId = BuiltInAgentProfileId | string;
+export type CapabilityReuseDecision = 'reuse_direct' | 'adapt_via_host_adapter' | 'borrow_mechanism' | 'avoid';
+export type SkillCapabilityKind = 'skill' | 'mcp' | 'cli_tool' | 'host_tool' | 'project_agent' | 'external_pattern';
+export type SkillCapabilitySource = 'project' | 'user_global' | 'claude_code' | 'mcp' | 'open_source' | 'host';
+export type SkillCapabilityEvidenceType = 'none' | 'command_output' | 'test_result' | 'browser_snapshot' | 'artifact' | 'external_source' | 'execution_record';
+export type CapabilitySourceKind = 'native_host' | 'mcp_tool' | 'open_source_material' | 'mechanism_reference' | 'future_adapter' | 'project_material';
+export type ExternalPackImportStatus = 'approved' | 'quarantined' | 'denied';
+export type ExternalPackCheckStatus = 'pass' | 'warn' | 'fail' | 'not_run';
+export type ToolPermissionPolicy = 'allow' | 'ask' | 'deny';
+export type AgentRouterCategory = 'planning' | 'implementation' | 'implementation_review' | 'validation' | 'security_research' | 'external_research' | 'blocked';
+export type TeamModeDecisionStatus = 'disabled' | 'enabled' | 'blocked';
+export type TeamModeActivation = 'auto' | 'force' | 'off';
+export type TeamModeSelection = 'off' | 'inspect' | 'review-lite' | 'hyperplan' | 'security-research';
+export type TeamModeCostClass = 'none' | 'low' | 'medium' | 'high';
+export type TeamModeCostRoute = 'not_applicable' | 'downgraded' | 'no_downgrade' | 'blocked';
+export type AgentExecutionRecordStatus = 'claimed' | 'completed' | 'failed' | 'blocked' | 'skipped';
+export type TeamSessionRecordStatus = 'created' | 'completed' | 'blocked' | 'disabled';
+export interface AgentProfileContract {
+    version: typeof AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION;
+    id: AgentProfileId;
+    stageScope: string[];
+    riskCeiling: LifecycleAutonomyCeiling;
+    defaultAutonomy: LifecycleAutonomyCeiling;
+    requiredArtifacts: string[];
+    toolScope: string[];
+    modelPolicyId: string;
+    hostCapabilityRequirements: string[];
+    boundaries: string[];
+}
+export interface SkillCapabilityContract {
+    version: typeof AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION;
+    id: string;
+    name: string;
+    kind: SkillCapabilityKind;
+    source: SkillCapabilitySource;
+    sourceRef: string;
+    capabilityDomain: string[];
+    allowedStages: string[];
+    requiredRiskCeiling: LifecycleAutonomyCeiling;
+    evidenceType: SkillCapabilityEvidenceType;
+    reuseDecision: CapabilityReuseDecision;
+    buildExceptionReason: string | null;
+}
+export interface CapabilitySourceCatalogEntry {
+    version: typeof CAPABILITY_SOURCE_CATALOG_VERSION;
+    id: string;
+    name: string;
+    kind: CapabilitySourceKind;
+    sourceRef: string;
+    reuseDecision: CapabilityReuseDecision;
+    quarantineRequired: boolean;
+    allowedUse: string;
+    attribution: string;
+    rationale: string;
+}
+export type RuntimeRegistryOrigin = 'built_in' | 'project_config' | 'external_manifest';
+export interface RuntimeRegistryEntrySource {
+    id: string;
+    kind: 'profile' | 'skill_capability' | 'capability_source';
+    origin: RuntimeRegistryOrigin;
+    sourceId: string | null;
+    quarantineRequired: boolean;
+}
+export interface AgentRuntimeRoutingRuleWhen {
+    keywords: string[];
+    affectedFileGlobs: string[];
+}
+export interface AgentRuntimeRoutingRule {
+    id: string;
+    when: AgentRuntimeRoutingRuleWhen;
+    preferProfile: AgentProfileId;
+    requireCapabilities: string[];
+    category: AgentRouterCategory | null;
+}
+export interface AgentRuntimeAdapterMapping {
+    profile: AgentProfileId;
+    hostAdapter: string;
+    projection: string;
+    permissionPolicy: string;
+}
+export interface AgentRuntimeAliasResolution {
+    input: string;
+    resolved: AgentProfileId;
+    source: 'built_in' | 'project_config';
+}
+export interface ProjectAgentRuntimeConfig {
+    profiles: AgentProfileContract[];
+    skillCapabilities: SkillCapabilityContract[];
+    capabilitySources: CapabilitySourceCatalogEntry[];
+    aliases: Record<string, string>;
+    routingRules: AgentRuntimeRoutingRule[];
+    adapterMappings: AgentRuntimeAdapterMapping[];
+}
+export interface ExternalAgentPackImportCheck {
+    check: string;
+    status: ExternalPackCheckStatus;
+    evidence: string;
+}
+export interface ExternalAgentPackImportInspection {
+    version: typeof EXTERNAL_AGENT_PACK_IMPORT_POLICY_VERSION;
+    sourceId: string;
+    status: ExternalPackImportStatus;
+    checks: ExternalAgentPackImportCheck[];
+    mappingResult: string;
+    allowedProfiles: AgentProfileId[];
+    riskCeiling: LifecycleAutonomyCeiling;
+    reason: string;
+}
+export interface ModelPolicyContract {
+    id: string;
+    category: string;
+    fallbackPolicy: string;
+    hostProjection: string;
+}
+export interface ToolPermissionSpec {
+    version: typeof TOOL_PERMISSION_SPEC_VERSION;
+    profile: AgentProfileId;
+    risk: string[];
+    toolGroups: string[];
+    fileScope: string[];
+    policy: ToolPermissionPolicy;
+    approvalPolicy: string;
+    runtimeValidationRequired: boolean;
+    deniedTools: string[];
+    hostPermissionProjection: string;
+}
+export interface HostAdapterContract {
+    version: typeof HOST_ADAPTER_CONTRACT_VERSION;
+    id: string;
+    host: string;
+    responsibilities: string[];
+    forbiddenAuthority: string[];
+    projections: string[];
+}
+export interface DelegationWavePolicy {
+    id: string;
+    waveKind: 'hyperplan' | 'security_research' | 'implementation_review' | 'validation';
+    memberProfiles: AgentProfileId[];
+    requiredArtifacts: string[];
+    fileOwnershipRequired: boolean;
+    mergeGate: string;
+}
+export interface TeamModePolicy {
+    version: typeof TEAM_MODE_POLICY_VERSION;
+    enabled: boolean;
+    decision: TeamModeDecisionStatus;
+    mode: TeamModeSelection;
+    activation: TeamModeActivation;
+    costClass: TeamModeCostClass;
+    reason: string;
+    costRoute: TeamModeCostRoute;
+    downgradeReason: string | null;
+    trustPolicyEnforced: boolean;
+    chiefProfile: AgentProfileId;
+    memberProfiles: AgentProfileId[];
+    allowedWaves: DelegationWavePolicy[];
+    maxMembers: number;
+    requireArtifacts: boolean;
+    blockedReason: string | null;
+    waveRecommendation: string[];
+}
+export interface EvidenceIngestionContract {
+    version: typeof EVIDENCE_INGESTION_CONTRACT_VERSION;
+    sourceOutputs: string[];
+    evidenceTargets: string[];
+    canonicalTruth: string;
+    forbiddenTruthSources: string[];
+}
+export interface AgentExecutionRecord {
+    version: typeof AGENT_EXECUTION_RECORD_CONTRACT_VERSION;
+    executionId: string;
+    runId: string;
+    taskId: string;
+    profile: AgentProfileId;
+    category: AgentRouterCategory;
+    host: string;
+    hostSessionId: string | null;
+    hostTaskId: string | null;
+    modelPolicy: ModelPolicyContract;
+    toolPermission: ToolPermissionSpec | null;
+    capabilitiesUsed: string[];
+    sourceAttribution: string[];
+    artifacts: string[];
+    status: AgentExecutionRecordStatus;
+    delegationId: string | null;
+    queueItemId: string | null;
+    ingestionStatus: ArtifactResultIngestionStatus | null;
+    resultStatus: SddResultStatus | null;
+    routeId: string;
+    routeDecision: Pick<AgentRouterDecision, 'version' | 'category' | 'recommendedProfile' | 'autonomyCeiling' | 'requiredCapabilities' | 'blockedReason'>;
+    evidenceSummary: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TeamMessageRecord {
+    sender: AgentProfileId | 'runtime';
+    receiver: AgentProfileId | 'team' | 'runtime';
+    taskRef: string | null;
+    artifactRefs: string[];
+    blocker: string | null;
+    evidenceSummary: string;
+    createdAt: string;
+}
+export interface TeamSessionRecord {
+    version: typeof TEAM_SESSION_RECORD_CONTRACT_VERSION;
+    teamId: string;
+    runId: string;
+    taskId: string | null;
+    status: TeamSessionRecordStatus;
+    chiefProfile: AgentProfileId;
+    memberProfiles: AgentProfileId[];
+    hostLayout: string | null;
+    teamMode: TeamModePolicy;
+    waves: DelegationWavePolicy[];
+    messages: TeamMessageRecord[];
+    artifacts: string[];
+    evidenceSummary: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AgentRouterRejectedProfile {
+    profile: AgentProfileId;
+    reason: string;
+}
+export interface AgentRouterDecision {
+    version: typeof AGENT_ROUTER_CONTRACT_VERSION;
+    taskId: string;
+    branch: string;
+    category: AgentRouterCategory;
+    recommendedProfile: AgentProfileId | null;
+    allowedProfiles: AgentProfileId[];
+    rejectedProfiles: AgentRouterRejectedProfile[];
+    requiredCapabilities: string[];
+    sourceCapability: string | null;
+    reuseDecision: CapabilityReuseDecision | null;
+    toolPermission: ToolPermissionSpec | null;
+    modelPolicy: ModelPolicyContract;
+    teamMode: TeamModePolicy;
+    autonomyCeiling: LifecycleAutonomyCeiling;
+    requiredArtifacts: string[];
+    blockedReason: string | null;
+    nextAction: string;
+    registrySources?: RuntimeRegistryEntrySource[];
+    resolvedAliases?: AgentRuntimeAliasResolution[];
+    routingRuleHits?: string[];
+    quarantineWarnings?: string[];
+    adapterMapping?: AgentRuntimeAdapterMapping | null;
+    cache?: RouteCacheMetadata;
+    profile?: RuntimeProfileSpan[];
+}
+export interface RouteCacheMetadata {
+    contract: typeof ROUTE_CACHE_CONTRACT_VERSION;
+    key: string;
+    status: 'hit' | 'miss' | 'stored';
+    source: 'content_addressed_derived_route';
+    authoritative: false;
+}
+export interface RuntimeProfileSpan {
+    contract: typeof RUNTIME_PROFILE_CONTRACT_VERSION;
+    name: string;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+}
+export interface AgentSkillTeamRuntimeInspection {
+    version: typeof AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION;
+    profiles: AgentProfileContract[];
+    skillCapabilities: SkillCapabilityContract[];
+    capabilitySources: CapabilitySourceCatalogEntry[];
+    hostAdapter: HostAdapterContract;
+    evidenceIngestion: EvidenceIngestionContract;
+    teamMode: TeamModePolicy;
+    reusePolicy: string;
+    registrySources?: RuntimeRegistryEntrySource[];
+    aliases?: Record<string, string>;
+    routingRules?: AgentRuntimeRoutingRule[];
+    adapterMappings?: AgentRuntimeAdapterMapping[];
+}
+export interface SkillCapabilityRegistry {
+    version: typeof AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION;
+    capabilities: SkillCapabilityContract[];
+    registrySources?: RuntimeRegistryEntrySource[];
+}
+export interface CapabilitySourceCatalog {
+    version: typeof CAPABILITY_SOURCE_CATALOG_VERSION;
+    sources: CapabilitySourceCatalogEntry[];
+    registrySources?: RuntimeRegistryEntrySource[];
+}
+export interface AgentSkillTeamRuntimeValidation {
+    version: typeof AGENT_SKILL_TEAM_RUNTIME_CONTRACT_VERSION;
+    valid: boolean;
+    inspection: AgentSkillTeamRuntimeInspection;
+    issues: ContractValidationIssue[];
+}
+export type QuerySurfaceId = 'status' | 'doctor' | 'run_inspect' | 'debug';
+export interface QueryStatusSurface {
+    id: QuerySurfaceId;
+    command: string;
+    responsibility: string;
+    includes: string[];
+    excludes: string[];
+    nextActionRule: string;
+}
+export interface QueryStatusContract {
+    version: typeof QUERY_STATUS_CONTRACT_VERSION;
+    sourceDocument: string;
+    surfaces: QueryStatusSurface[];
+}
+export interface QueryStatusValidation {
+    version: typeof QUERY_STATUS_CONTRACT_VERSION;
+    valid: boolean;
+    surfaces: QueryStatusSurface[];
+    issues: ContractValidationIssue[];
+}
+export type SkillAgentEvalDimensionId = 'novel_judgment' | 'risk_identification' | 'task_slicing' | 'agent_evidence' | 'output_concision' | 'verification_executability' | 'autonomy_correctness' | 'agent_fit' | 'verification_availability' | 'gap_closure';
+export interface SkillAgentEvalDimension {
+    id: SkillAgentEvalDimensionId;
+    expectation: string;
+    baselineFinding: string;
+    passThreshold: number;
+}
+export interface SkillAgentEvalContract {
+    version: typeof SKILL_AGENT_EVAL_CONTRACT_VERSION;
+    corpus: string[];
+    sourceReport: string;
+    dimensions: SkillAgentEvalDimension[];
+    regressionAssertions: string[];
+}
+export interface SkillAgentEvalValidation {
+    version: typeof SKILL_AGENT_EVAL_CONTRACT_VERSION;
+    valid: boolean;
+    contract: SkillAgentEvalContract;
+    issues: ContractValidationIssue[];
+}
+export type HarnessLearningSinkId = 'project_context_pack' | 'risk_vocabulary' | 'checklist' | 'doctor_check' | 'eval_assertion' | 'generated_entry_guidance';
+export interface HarnessLearningSink {
+    id: HarnessLearningSinkId;
+    output: string;
+    boundary: string;
+}
+export interface HarnessLearningContract {
+    version: typeof HARNESS_LEARNING_CONTRACT_VERSION;
+    sourceTrial: string;
+    allowedSinks: HarnessLearningSink[];
+    forbiddenOutputs: string[];
+    promotionRule: string;
+}
+export interface HarnessLearningValidation {
+    version: typeof HARNESS_LEARNING_CONTRACT_VERSION;
+    valid: boolean;
+    contract: HarnessLearningContract;
+    issues: ContractValidationIssue[];
+}
+export interface ProjectContextPackContract {
+    version: typeof PROJECT_CONTEXT_PACK_CONTRACT_VERSION;
+    entryPoint: string;
+    durableContext: string[];
+    runtimeSourcesOfTruth: string[];
+    boundaries: string[];
+}
+export interface ProjectContextPackValidation {
+    version: typeof PROJECT_CONTEXT_PACK_CONTRACT_VERSION;
+    valid: boolean;
+    contract: ProjectContextPackContract;
+    issues: ContractValidationIssue[];
+}
 export interface SddResult {
     contract: typeof SDD_RESULT_CONTRACT;
     version: typeof SDD_RESULT_VERSION;
@@ -644,9 +1257,179 @@ export interface SddResultValidationReport {
     valid: boolean;
     result: SddResult | null;
     issues: ContractValidationIssue[];
+    trust?: ArtifactTrustValidationReport;
+}
+export interface EvidenceItem {
+    kind: string;
+    ref: string;
+    summary: string | null;
+}
+export interface EvidenceClaim {
+    contract: typeof SDD_EVIDENCE_CONTRACT;
+    version: typeof SDD_EVIDENCE_VERSION;
+    task: string;
+    acceptance: string;
+    status: EvidenceCoverageStatus;
+    claim: string;
+    sourceArtifact: string;
+    evidence: EvidenceItem[];
+    provenance: string[];
+    policy: string[];
+    rawMetadata: Record<string, string | string[]>;
+}
+export interface EvidenceReasoning {
+    summary: string;
+    ruleIds: string[];
+    issueCodes: EvidenceQualityIssue[];
+}
+export interface PolicyRuleSet {
+    id: typeof ACCEPTANCE_POLICY_RULESET_VERSION;
+    version: string;
+    ruleIds: string[];
+}
+export interface PolicyDecision {
+    status: EvidenceCoverageStatus;
+    ruleSet: PolicyRuleSet;
+    passedRules: string[];
+    failedRules: string[];
+    issueCodes: EvidenceQualityIssue[];
+}
+export interface EvidenceCoverage {
+    acceptanceId: string;
+    status: EvidenceCoverageStatus;
+    claim?: EvidenceClaim;
+    evidence: EvidenceItem[];
+    reasoning?: EvidenceReasoning;
+    policyDecision: PolicyDecision;
+}
+export interface ProvenanceEntity {
+    id: string;
+    kind: 'spec' | 'plan' | 'tasks' | 'artifact' | 'command_output' | 'run_state' | 'material' | string;
+    hash?: string;
+    path?: string;
+}
+export interface ProvenanceActivity {
+    id: string;
+    kind: 'inspect' | 'route' | 'do' | 'verify' | 'artifact_validate' | 'sync_back' | 'policy_evaluate' | 'cache' | string;
+    startedAt?: string;
+    endedAt?: string;
+}
+export interface ProvenanceAgent {
+    id: string;
+    kind: 'runtime' | 'implementer' | 'reviewer' | 'validator' | 'tool' | string;
+}
+export interface ProvenanceLink {
+    relation: 'used' | 'wasGeneratedBy' | 'wasAssociatedWith' | 'wasDerivedFrom' | string;
+    from: string;
+    to: string;
+}
+export interface SddEvidenceAttestation {
+    subject: string;
+    materials: ProvenanceEntity[];
+    invocation: ProvenanceActivity;
+    builder: ProvenanceAgent;
+}
+export interface ArtifactTrustValidationReport {
+    valid: boolean;
+    claims: EvidenceClaim[];
+    issues: ContractValidationIssue[];
+}
+export type InvocationLedgerKind = 'command' | 'tool_invocation' | 'agent' | 'skill' | 'material' | 'policy_evaluation' | 'cache' | 'artifact_hash';
+export interface InvocationLedgerEntry {
+    contract: 'sdd-invocation-ledger-v1';
+    version: typeof INVOCATION_LEDGER_CONTRACT_VERSION;
+    entryId: string;
+    runId: string;
+    taskId: string | null;
+    branch: string | null;
+    kind: InvocationLedgerKind;
+    ref: string;
+    status: string;
+    timestamp: string;
+    artifactPath?: string | null;
+    inputHash?: string | null;
+    outputHash?: string | null;
+    materialRefs: string[];
+    metadata: Record<string, string | number | boolean | null>;
+}
+export interface ContextBudget {
+    contract: typeof CONTEXT_BUDGET_CONTRACT_VERSION;
+    profile: ContextProfile;
+    maxBytes: number;
+    preserve: string[];
+}
+export interface ContextSourceRef {
+    path: string;
+    hash: string;
+    kind: ContextSourceKind;
+}
+export interface CommandOutputSummary {
+    contract: typeof COMMAND_OUTPUT_SUMMARY_CONTRACT_VERSION;
+    authoritative: false;
+    usableForPass: false;
+    source: ContextSourceRef;
+    status: ContextSummaryStatus;
+    highlights: string[];
+    omittedLines: number;
+}
+export interface EvidenceSummaryProjection {
+    contract: typeof EVIDENCE_SUMMARY_CONTRACT_VERSION;
+    authoritative: false;
+    usableForPass: false;
+    runId: string;
+    taskId: string | null;
+    sources: ContextSourceRef[];
+    passCount: number;
+    blockedCount: number;
+    failCount: number;
+    issueCodes: EvidenceQualityIssue[];
+    policyRefs: string[];
+    highlights: string[];
+}
+export interface ContextBuildPackage {
+    contract: typeof CONTEXT_PACKAGE_CONTRACT_VERSION;
+    profile: ContextProfile;
+    mode: ContextBuildMode;
+    agent: string | null;
+    authoritative: false;
+    usableForPass: false;
+    taskId: string;
+    branch: string;
+    mustRead: ContextSourceRef[];
+    optionalRead: ContextSourceRef[];
+    doNotReadUnlessNeeded: ContextSourceRef[];
+    nextCommands: string[];
+    warnings: string[];
+}
+export interface LogWorkerSummary {
+    contract: typeof LOG_WORKER_SUMMARY_CONTRACT_VERSION;
+    authoritative: false;
+    usableForPass: false;
+    runId: string;
+    taskId: string | null;
+    workerId: string;
+    sources: ContextSourceRef[];
+    highlights: string[];
+    forbiddenAuthority: string[];
+}
+export interface EvidenceSummaryOptions {
+    runId: string;
+    taskId?: string;
+}
+export interface ContextBuildOptions {
+    taskId: string;
+    branch?: string;
+    mode: ContextBuildMode;
+    agent?: string;
+    profile?: ContextProfile;
+}
+export interface LogWorkerSummaryValidation {
+    valid: boolean;
+    issues: ContractValidationIssue[];
 }
 export interface SddResultArtifactTemplateOptions {
     branch?: string;
+    runId?: string;
     taskId: string;
     agent: string;
     artifactPath: string;
@@ -685,6 +1468,8 @@ export interface SingleTaskLoopOptions {
     reviewArtifact?: string;
     validationArtifact?: string;
     debugArtifact?: string;
+    teamModeEnabled?: boolean;
+    teamModeActivation?: TeamModeActivation;
 }
 export interface SingleTaskLoopResult {
     runId: string;
@@ -695,19 +1480,22 @@ export interface SingleTaskLoopResult {
     requiredArtifacts: string[];
     acceptedArtifacts: string[];
     syncBackProposalPath: string;
+    routeDecision: AgentRouterDecision;
     message: string;
 }
 export interface GoalVerifyOptions {
     branch?: string;
     taskId: string;
-    runId: string;
+    runId?: string;
     reviewArtifact?: string;
     validationArtifact?: string;
 }
 export interface AcceptanceCoverageItem {
     acceptance: string;
-    status: GoalVerifyStatus | 'GAP';
+    status: EvidenceCoverageStatus;
     evidence: string;
+    policyDecision?: PolicyDecision;
+    issueCodes?: EvidenceQualityIssue[];
 }
 export interface GoalVerifyResult {
     runId: string;
@@ -721,6 +1509,7 @@ export interface GoalVerifyResult {
     acceptanceCoverage: AcceptanceCoverageItem[];
     gaps: SddTaskGap[];
     commands: string[];
+    standardStatus: HarnessVerifyStatus;
     message: string;
 }
 export interface RunSummary {
@@ -728,6 +1517,11 @@ export interface RunSummary {
     status: RunStatus;
     phase: string | null;
     currentTask: string | null;
+    partition: string | null;
+    gitBranch: string | null;
+    taskId: string | null;
+    affectedFiles: string[];
+    documentSnapshot: RunDocumentSnapshot;
     createdAt: string;
     updatedAt: string;
     validationStatus: RunState['validation']['status'];
@@ -737,6 +1531,9 @@ export interface RunSummary {
 }
 export interface LocalRunIndexTaskEntry {
     taskId: string;
+    partition: string | null;
+    gitBranch: string | null;
+    affectedFiles: string[];
     status: string | null;
     runId: string;
     runStatus: RunStatus;
@@ -755,9 +1552,31 @@ export interface LocalRunIndexWaveSummary {
     eventCount: number;
     lastEvent: string | null;
 }
+export interface LocalRunIndexPartitionTaskEntry {
+    partition: string;
+    gitBranch: string | null;
+    taskId: string;
+    runId: string;
+    runStatus: RunStatus;
+    validationStatus: RunState['validation']['status'];
+    syncBackStatus: RunState['syncBack']['status'];
+    affectedFiles: string[];
+    updatedAt: string;
+}
+export interface LocalRunIndexAffectedFileEntry {
+    file: string;
+    partition: string;
+    gitBranch: string | null;
+    taskId: string;
+    runId: string;
+    runStatus: RunStatus;
+    syncBackStatus: RunState['syncBack']['status'];
+    updatedAt: string;
+}
 export interface LocalRunIndexQuery {
     runId?: string;
     taskId?: string;
+    partition?: string;
     status?: RunStatus;
     artifact?: string;
 }
@@ -769,6 +1588,8 @@ export interface LocalRunIndex {
     delegations: DelegationQueueItem[];
     artifacts: LocalRunIndexArtifactEntry[];
     waves: LocalRunIndexWaveSummary[];
+    latestByPartitionTask: LocalRunIndexPartitionTaskEntry[];
+    activeByAffectedFile: LocalRunIndexAffectedFileEntry[];
 }
 export interface LocalRunIndexInspection {
     valid: boolean;
@@ -777,6 +1598,32 @@ export interface LocalRunIndexInspection {
     index: LocalRunIndex | null;
     issues: ContractValidationIssue[];
 }
+export interface TaskRunEvidenceContract {
+    version: typeof TASK_RUN_EVIDENCE_CONTRACT_VERSION;
+    runId: string;
+    state: {
+        status: RunStatus;
+        phase: string | null;
+        currentTask: string | null;
+    };
+    events: Array<{
+        event: string;
+        summary: string | null;
+        task: string | null;
+        agent: string | null;
+        gate: string | null;
+        validation: string | null;
+        gap: string | null;
+    }>;
+    artifacts: ArtifactIndexEntry[];
+    validation: RunState['validation'];
+    gaps: SddTaskGap[];
+    syncBackProposal: string | null;
+    invocationLedger: InvocationLedgerEntry[];
+    agentExecutions: AgentExecutionRecord[];
+    teamSessions: TeamSessionRecord[];
+    workerRuntimes: ResidentWorkerRuntimeRecord[];
+}
 export interface RunInspection {
     summary: RunSummary;
     state: RunState;
@@ -789,9 +1636,38 @@ export interface RunInspection {
     validation: RunState['validation'];
     syncBack: RunState['syncBack'];
     tasks: Record<string, unknown>;
+    taskRunEvidence: TaskRunEvidenceContract;
+    agentExecutions: AgentExecutionRecord[];
+    invocationLedger: InvocationLedgerEntry[];
+    teamSessions: TeamSessionRecord[];
+    workerRuntimes: ResidentWorkerRuntimeRecord[];
+}
+export interface RunEvidenceSummary {
+    agentExecutions: number;
+    teamSessions: number;
+    artifactIngestions: number;
+    workerRuntimes: number;
+    staleWorkerRuntimes: number;
+    routePreflight: boolean;
+    tasksChangedAfterRun: boolean;
+    tasksUpdatedAt: string | null;
+    runUpdatedAt: string | null;
+}
+export interface ResolvedTaskRun {
+    runId: string;
+    state: RunState;
+    context: ContextResolverContract;
+    model: SddTaskModel;
+    task: SddTask | null;
+    explicitRunId: boolean;
+    staleReasons: string[];
+    affectedFileConflicts: LocalRunIndexAffectedFileEntry[];
 }
 export interface ProjectStatus {
     branch: string;
+    workflowStatus: 'active' | 'not_started';
+    context: ContextResolverContract;
+    gitRoot: string | null;
     documents: SddTaskModel['documents'];
     tasks: {
         total: number;
@@ -804,6 +1680,10 @@ export interface ProjectStatus {
         gaps: number;
     };
     latestRun: RunSummary | null;
+    latestRunsByTask: LocalRunIndexPartitionTaskEntry[];
+    latestRunEvidence: RunEvidenceSummary | null;
+    latestRunStaleReasons: string[];
+    affectedFileConflicts: LocalRunIndexAffectedFileEntry[];
     recommendedNextCommand: string;
     gaps: SddTaskGap[];
 }
@@ -820,6 +1700,8 @@ export interface SyncBackInspection {
     reasons: string[];
     proposalPath: string | null;
     proposal: string | null;
+    proposalDigest: string | null;
+    proposalDigestValid: boolean | null;
     runTaskStatus: string | null;
     markdownTask: SddTask | null;
     markdownStatus: SddTaskStatus | null;
@@ -827,6 +1709,8 @@ export interface SyncBackInspection {
     artifacts: string[];
     gaps: SddTaskGap[];
     applyPolicy: SyncBackApplyPolicy;
+    staleReasons: string[];
+    affectedFileConflicts: LocalRunIndexAffectedFileEntry[];
 }
 export interface SyncBackApplyResult {
     runId: string;
@@ -841,8 +1725,17 @@ export declare function getSddDir(projectRoot: string): string;
 export declare function getProjectConfigPath(projectRoot: string): string;
 export declare function getRunsDir(projectRoot: string): string;
 export declare function getLocalRunIndexPath(projectRoot: string): string;
+export declare function getRuntimeStorePath(projectRoot: string): string;
 export declare function getRunDir(projectRoot: string, runId: string): string;
 export declare function getArtifactsDir(projectRoot: string, runId: string): string;
+export declare function getAgentExecutionsDir(projectRoot: string, runId: string): string;
+export declare function getTeamSessionsDir(projectRoot: string, runId: string): string;
+export declare function getWorkerRuntimesDir(projectRoot: string, runId: string): string;
+export declare function getInvocationLedgerPath(projectRoot: string, runId: string): string;
+export declare function getRouteCacheDir(projectRoot: string): string;
+export declare function getWorkerRuntimeRecordPath(projectRoot: string, runId: string, runtimeId: string): string;
+export declare function getAgentExecutionRecordPath(projectRoot: string, runId: string, executionId: string): string;
+export declare function getTeamSessionRecordPath(projectRoot: string, runId: string, teamId: string): string;
 export declare function getArtifactPath(projectRoot: string, runId: string, relativeArtifactPath: string): string;
 export declare function getRunRelativeArtifactPath(artifactRootRelativePath: string): string;
 export declare function toArtifactRootRelativePath(runRelativeArtifactPath: string): string;
@@ -851,6 +1744,15 @@ export declare function writeArtifact(projectRoot: string, runId: string, artifa
     runRelativePath: string;
 }>;
 export declare function readArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string): Promise<string>;
+export declare function appendInvocationLedgerEntry(projectRoot: string, input: Omit<InvocationLedgerEntry, 'contract' | 'version' | 'entryId' | 'timestamp'>): Promise<InvocationLedgerEntry>;
+export declare function listInvocationLedgerEntries(projectRoot: string, runId: string): Promise<InvocationLedgerEntry[]>;
+export declare function writeAgentExecutionRecord(projectRoot: string, record: AgentExecutionRecord): Promise<AgentExecutionRecord>;
+export declare function writeTeamSessionRecord(projectRoot: string, record: TeamSessionRecord): Promise<TeamSessionRecord>;
+export declare function writeResidentWorkerRuntimeRecord(projectRoot: string, record: ResidentWorkerRuntimeRecord): Promise<ResidentWorkerRuntimeRecord>;
+export declare function listAgentExecutionRecords(projectRoot: string, runId: string): Promise<AgentExecutionRecord[]>;
+export declare function listTeamSessionRecords(projectRoot: string, runId: string): Promise<TeamSessionRecord[]>;
+export declare function readResidentWorkerRuntimeRecord(projectRoot: string, runId: string, runtimeId: string): Promise<ResidentWorkerRuntimeRecord>;
+export declare function listResidentWorkerRuntimeRecords(projectRoot: string, runId: string): Promise<ResidentWorkerRuntimeRecord[]>;
 export type InitDocumentStatus = 'created' | 'unchanged' | 'overwritten' | 'skipped';
 export interface InitDocumentReport {
     branch: string;
@@ -892,16 +1794,32 @@ export declare function readLocalRunIndex(projectRoot: string): Promise<LocalRun
 export declare function queryLocalRunIndex(projectRoot: string, query?: LocalRunIndexQuery): Promise<LocalRunIndex>;
 export declare function inspectLocalRunIndex(projectRoot: string): Promise<LocalRunIndexInspection>;
 export declare function inspectRun(projectRoot: string, runId: string): Promise<RunInspection>;
+export declare function parseContextProfile(value: string | null | undefined): ContextProfile;
+export declare function contextBudgetForProfile(profile: ContextProfile): ContextBudget;
+export declare function summarizeCommandOutput(rawOutput: string, source: ContextSourceRef, profile?: ContextProfile): CommandOutputSummary;
+export declare function buildEvidenceSummaryProjection(projectRoot: string, options: EvidenceSummaryOptions): Promise<EvidenceSummaryProjection>;
+export declare function buildContextBuildPackage(projectRoot: string, options: ContextBuildOptions): Promise<ContextBuildPackage>;
+export declare function validateLogWorkerSummary(summary: LogWorkerSummary): LogWorkerSummaryValidation;
+export declare function resolveSddContext(projectRoot: string, options?: {
+    branch?: string | null;
+    branchSource?: ContextBranchSource;
+}): Promise<ContextResolverContract>;
 export declare function getProjectStatus(projectRoot: string, options?: {
-    branch?: string;
+    branch?: string | null;
+    branchSource?: ContextBranchSource;
 }): Promise<ProjectStatus>;
+export declare function resolveTaskRun(projectRoot: string, options: {
+    runId?: string;
+    branch?: string;
+    taskId: string;
+}): Promise<ResolvedTaskRun>;
 export declare function inspectSyncBack(projectRoot: string, options: {
-    runId: string;
+    runId?: string;
     branch?: string;
     taskId?: string;
 }): Promise<SyncBackInspection>;
 export declare function applySyncBack(projectRoot: string, options: {
-    runId: string;
+    runId?: string;
     branch?: string;
     taskId?: string;
     approved?: boolean;
@@ -909,6 +1827,7 @@ export declare function applySyncBack(projectRoot: string, options: {
 export declare function doctor(projectRoot: string, options?: {
     allRuns?: boolean;
     latestOnly?: boolean;
+    branch?: string | null;
 }): Promise<DoctorReport>;
 export declare function parseSddBranch(projectRoot: string, branch?: string): Promise<SddTaskModel>;
 export declare function parseSddTasksMarkdown(raw: string, options?: {
@@ -927,6 +1846,10 @@ export declare function validateSddResult(result: SddResult, options?: {
     expectedAgent?: string;
     runRelativeArtifactPath?: string;
 }): ContractValidationIssue[];
+export declare function parseSddEvidenceMarkdown(raw: string, options?: {
+    expectedTask?: string;
+    sourceArtifact?: string;
+}): ArtifactTrustValidationReport;
 export declare function createDelegationRecord(input: {
     delegationId: string;
     task: string;
@@ -970,6 +1893,15 @@ export declare function inspectWavePlan(projectRoot: string, options?: {
 }): Promise<WavePlan>;
 export declare function runBackgroundExecutor(projectRoot: string, options: BackgroundExecutorRunOptions): Promise<BackgroundExecutorResult>;
 export declare function inspectBackgroundExecutor(projectRoot: string, runId: string): Promise<BackgroundExecutorInspection>;
+export declare function claimResidentWorkerRuntime(projectRoot: string, options: ResidentWorkerRuntimeClaimOptions): Promise<ResidentWorkerRuntimeClaimResult>;
+export declare function heartbeatResidentWorkerRuntime(projectRoot: string, options: ResidentWorkerRuntimeHeartbeatOptions): Promise<ResidentWorkerRuntimeHeartbeatResult>;
+export declare function listResidentWorkerRuntimes(projectRoot: string, options: {
+    runId: string;
+}): Promise<ResidentWorkerRuntimeList>;
+export declare function inspectResidentWorkerRuntime(projectRoot: string, options: {
+    runId: string;
+    runtimeId: string;
+}): Promise<ResidentWorkerRuntimeInspection>;
 export declare function runWaveExecutor(projectRoot: string, options?: WaveExecutorRunOptions): Promise<WaveExecutorResult>;
 export declare function inspectWaveExecutor(projectRoot: string, runId: string): Promise<WaveExecutorInspection>;
 export declare function renderDoctorReport(report: DoctorReport): string;
@@ -1004,6 +1936,42 @@ export declare function listToolPluginContracts(projectRoot: string): Promise<To
 export declare function inspectToolPluginContract(projectRoot: string, pluginId: string): Promise<ToolPluginContract | null>;
 export declare function listWorkerAdapterContracts(projectRoot: string): Promise<WorkerAdapterContractRegistry>;
 export declare function inspectWorkerAdapterContract(projectRoot: string, adapterId: string): Promise<WorkerAdapterContract | null>;
+export declare function listWorkflowGates(projectRoot: string): Promise<WorkflowGateRegistry>;
+export declare function inspectWorkflowGate(projectRoot: string, workflowId: string): Promise<WorkflowGateContract | null>;
+export declare function validateWorkflowGates(projectRoot: string): Promise<WorkflowGateValidation>;
+export declare function listAgentRegistry(projectRoot: string): Promise<AgentRegistry>;
+export declare function inspectAgentRegistryEntry(projectRoot: string, agentId: string): Promise<AgentRegistryEntry | null>;
+export declare function validateAgentRegistry(projectRoot: string): Promise<AgentRegistryValidation>;
+export declare function inspectAgentSkillTeamRuntime(projectRoot: string): Promise<AgentSkillTeamRuntimeInspection>;
+export declare function validateAgentSkillTeamRuntime(projectRoot: string): Promise<AgentSkillTeamRuntimeValidation>;
+export declare function listSkillCapabilities(projectRoot: string): Promise<SkillCapabilityRegistry>;
+export declare function inspectSkillCapability(projectRoot: string, capabilityId: string): Promise<SkillCapabilityContract | null>;
+export declare function listCapabilitySources(projectRoot: string): Promise<CapabilitySourceCatalog>;
+export declare function inspectCapabilitySource(projectRoot: string, sourceId: string): Promise<CapabilitySourceCatalogEntry | null>;
+export declare function inspectExternalAgentPackImport(projectRoot: string, sourceId: string): Promise<ExternalAgentPackImportInspection>;
+export declare function inspectTeamModePolicy(projectRoot: string, options?: {
+    taskId?: string;
+    branch?: string;
+    enabled?: boolean;
+    teamModeActivation?: TeamModeActivation;
+}): Promise<TeamModePolicy>;
+export declare function routeSddTask(projectRoot: string, options?: {
+    taskId: string;
+    branch?: string;
+    agent?: string;
+    teamModeEnabled?: boolean;
+    teamModeActivation?: TeamModeActivation;
+    profile?: boolean;
+    cache?: boolean;
+}): Promise<AgentRouterDecision>;
+export declare function inspectQueryStatusContract(projectRoot: string): Promise<QueryStatusContract>;
+export declare function inspectSkillAgentEvalContract(projectRoot: string): Promise<SkillAgentEvalContract>;
+export declare function validateSkillAgentEvalContract(projectRoot: string): Promise<SkillAgentEvalValidation>;
+export declare function inspectHarnessLearningContract(projectRoot: string): Promise<HarnessLearningContract>;
+export declare function validateHarnessLearningContract(projectRoot: string): Promise<HarnessLearningValidation>;
+export declare function inspectProjectContextPackContract(projectRoot: string): Promise<ProjectContextPackContract>;
+export declare function validateProjectContextPackContract(projectRoot: string): Promise<ProjectContextPackValidation>;
+export declare function validateQueryStatusContract(projectRoot: string): Promise<QueryStatusValidation>;
 export declare function inspectGovernancePolicy(projectRoot: string): Promise<GovernancePolicy>;
 export declare function evaluateGovernancePolicy(projectRoot: string, input: GovernancePolicyDecisionInput): Promise<GovernancePolicyDecision>;
 export declare function listDelegationQueueItems(projectRoot: string, options?: {
@@ -1014,3 +1982,5 @@ export declare function getDelegationStateMachine(): DelegationStateMachine;
 export declare function validateDelegationStateTransition(from: DelegationStatus, to: DelegationStatus, event?: string | null): DelegationStateTransitionValidation;
 export declare function emptyLifecycleDecisionRecord(): LifecycleDecisionRecord;
 export declare function readRunEvents(projectRoot: string, runId: string): Promise<RuntimeEvent[]>;
+export declare function extractLifecycleRiskSignalsFromText(text: string, source?: LifecycleRiskExtractionSource): LifecycleRiskGateExtraction;
+export declare function lifecycleAutonomyCeiling(record: LifecycleDecisionRecord): LifecycleAutonomyCeiling;