sdd-agent-platform 0.1.0 → 0.2.0

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

@@ -20,6 +20,28 @@ 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 type DoctorLevel = 'PASS' | 'WARN' | 'FAIL';
 export type RunStatus = 'created' | 'running' | 'completed' | 'blocked' | 'failed' | 'archived';
 export type LifecycleProfile = 'direct' | 'compact' | 'full' | 'research';
@@ -28,6 +50,7 @@ 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 DetectionConfidence = 'high' | 'medium' | 'low';
 export interface DetectionEvidence {
@@ -68,6 +91,7 @@ export interface ProjectConfig {
     };
     sdd: {
         spec_dir: string;
+        default_branch?: string;
         docs_language: string;
         compatible_with: string;
     };
@@ -87,6 +111,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 +328,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 +393,7 @@ export interface LifecycleDecisionGateResult {
     record: LifecycleDecisionRecord;
     checkpointRequired: boolean;
     boundaries: string[];
+    autonomyCeiling: LifecycleAutonomyCeiling;
 }
 export interface ArtifactIndexEntry {
     path: string;
@@ -344,6 +402,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 +416,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;
@@ -411,6 +481,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 +513,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 +534,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 +559,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 +639,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 +806,399 @@ 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 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;
+    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;
+    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;
+}
+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;
@@ -685,6 +1258,8 @@ export interface SingleTaskLoopOptions {
     reviewArtifact?: string;
     validationArtifact?: string;
     debugArtifact?: string;
+    teamModeEnabled?: boolean;
+    teamModeActivation?: TeamModeActivation;
 }
 export interface SingleTaskLoopResult {
     runId: string;
@@ -695,12 +1270,13 @@ 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;
 }
@@ -721,6 +1297,7 @@ export interface GoalVerifyResult {
     acceptanceCoverage: AcceptanceCoverageItem[];
     gaps: SddTaskGap[];
     commands: string[];
+    standardStatus: HarnessVerifyStatus;
     message: string;
 }
 export interface RunSummary {
@@ -728,6 +1305,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 +1319,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 +1340,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 +1376,8 @@ export interface LocalRunIndex {
     delegations: DelegationQueueItem[];
     artifacts: LocalRunIndexArtifactEntry[];
     waves: LocalRunIndexWaveSummary[];
+    latestByPartitionTask: LocalRunIndexPartitionTaskEntry[];
+    activeByAffectedFile: LocalRunIndexAffectedFileEntry[];
 }
 export interface LocalRunIndexInspection {
     valid: boolean;
@@ -777,6 +1386,31 @@ 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;
+    agentExecutions: AgentExecutionRecord[];
+    teamSessions: TeamSessionRecord[];
+    workerRuntimes: ResidentWorkerRuntimeRecord[];
+}
 export interface RunInspection {
     summary: RunSummary;
     state: RunState;
@@ -789,9 +1423,37 @@ export interface RunInspection {
     validation: RunState['validation'];
     syncBack: RunState['syncBack'];
     tasks: Record<string, unknown>;
+    taskRunEvidence: TaskRunEvidenceContract;
+    agentExecutions: AgentExecutionRecord[];
+    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 +1466,10 @@ export interface ProjectStatus {
         gaps: number;
     };
     latestRun: RunSummary | null;
+    latestRunsByTask: LocalRunIndexPartitionTaskEntry[];
+    latestRunEvidence: RunEvidenceSummary | null;
+    latestRunStaleReasons: string[];
+    affectedFileConflicts: LocalRunIndexAffectedFileEntry[];
     recommendedNextCommand: string;
     gaps: SddTaskGap[];
 }
@@ -827,6 +1493,8 @@ export interface SyncBackInspection {
     artifacts: string[];
     gaps: SddTaskGap[];
     applyPolicy: SyncBackApplyPolicy;
+    staleReasons: string[];
+    affectedFileConflicts: LocalRunIndexAffectedFileEntry[];
 }
 export interface SyncBackApplyResult {
     runId: string;
@@ -843,6 +1511,12 @@ export declare function getRunsDir(projectRoot: string): string;
 export declare function getLocalRunIndexPath(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 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 +1525,13 @@ 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 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 +1573,26 @@ 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 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;
@@ -970,6 +1661,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 +1704,39 @@ 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;
+    teamModeEnabled?: boolean;
+    teamModeActivation?: TeamModeActivation;
+}): 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 +1747,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;