@treeseed/sdk 0.12.40 → 0.12.42

package/dist/agent-capacity.d.ts

@@ -1,6 +1,176 @@
 import type { CapacityGrant, CapacityLedgerEntry, CapacityPlan as LegacyCapacityPlan, CapacityProvider, CapacityReservation, ExecutionProvider, TaskUsageActual } from './sdk-types.js';
+import type { TreeseedContentRef } from './content-operations.js';
 import type { AgentRuntimeSpec, AgentWorkPackage, ExecutionCapabilityDemand, ExecutionCapabilitySupply, ExecutionProviderDescriptor, ExecutionResourceNeed } from './types/agents.js';
 export type AgentExecutionMode = 'planning' | 'acting';
+export type AgentPlanningActivityType = 'planning' | 'estimating' | 'reviewing' | 'reporting';
+export type ContentRef = TreeseedContentRef;
+export type AgentEstimateConfidence = 'low' | 'medium' | 'high';
+export type AgentEstimateRiskLevel = 'low' | 'medium' | 'high';
+export type DecisionDependencyType = 'artifact' | 'capability' | 'decision' | 'external-resource' | 'human-input';
+export interface AgentOutputRequirement {
+    id?: string;
+    outputType: string;
+    description?: string;
+    contentModel?: string;
+    required?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface DecisionDependencySpec {
+    id: string;
+    type: DecisionDependencyType;
+    requiredBefore: 'start' | 'complete' | 'review' | 'release';
+    optional?: boolean;
+    deliverableType?: string;
+    capability?: string;
+    agentClass?: string;
+    contentRefs?: string[];
+    humanInputPolicy?: {
+        requiredFrom: 'team-human' | 'any-human' | 'any-human-or-agent';
+        teamId?: string | null;
+    };
+    summary?: string;
+}
+export interface StructuredAgentEstimate {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId?: string | null;
+    proposalId?: string | null;
+    workUnitId?: string | null;
+    agentClass: string;
+    agentId?: string | null;
+    minCredits: number;
+    expectedCredits: number;
+    maxCredits: number;
+    confidence: AgentEstimateConfidence;
+    riskLevel: AgentEstimateRiskLevel;
+    assumptions: string[];
+    blockers: string[];
+    dependencies: DecisionDependencySpec[];
+    expectedOutputs: AgentOutputRequirement[];
+    acceptanceCriteria: string[];
+    completionEvidence: string[];
+    createdAt?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface DeliverableContract {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    deliverableType: string;
+    producerAgentClasses: string[];
+    reviewerAgentClasses?: string[];
+    requiredSections?: string[];
+    acceptanceCriteria: string[];
+    status: 'required' | 'draft' | 'submitted' | 'approved' | 'rejected';
+    metadata?: Record<string, unknown>;
+}
+export interface DeliverableManifest {
+    id: string;
+    deliverableContractId: string;
+    projectId: string;
+    decisionId: string;
+    producedRefs: ContentRef[];
+    coverage?: Record<string, ContentRef[]>;
+    summary: string;
+    readyForReview: boolean;
+    submittedByAgentId?: string | null;
+    submittedAt?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface DecisionAssignmentGraphNode {
+    id: string;
+    decisionId: string;
+    projectId: string;
+    targetAgentClass: string;
+    activityType: AgentPlanningActivityType | 'acting';
+    handler?: string | null;
+    requiredCapabilities: string[];
+    requiredDeliverableContractIds: string[];
+    inputRefs: ContentRef[];
+    outputRequirements: AgentOutputRequirement[];
+    capacity: {
+        expectedCredits: number;
+        maxCredits: number;
+    };
+    status: 'pending' | 'ready' | 'leased' | 'running' | 'blocked' | 'completed' | 'failed' | 'cancelled';
+    metadata?: Record<string, unknown>;
+}
+export interface DecisionAssignmentGraphEdge {
+    fromNodeId: string;
+    toNodeId: string;
+    edgeType: 'blocks-start' | 'blocks-completion' | 'blocks-release';
+    reason?: string;
+}
+export interface DecisionAssignmentGraph {
+    id: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    version: number;
+    status: 'draft' | 'compiled' | 'ready' | 'executing' | 'completed' | 'blocked';
+    estimateIds: string[];
+    deliverableContracts: DeliverableContract[];
+    nodes: DecisionAssignmentGraphNode[];
+    edges: DecisionAssignmentGraphEdge[];
+    compiledAt?: string | null;
+    compiledBy: 'api-control-plane';
+    metadata?: Record<string, unknown>;
+}
+export interface AgentCapacityContractDiagnostic {
+    severity: 'info' | 'warning' | 'error';
+    code: string;
+    message: string;
+    path?: string;
+}
+export interface AgentCapacityContractValidationResult {
+    ok: boolean;
+    diagnostics: AgentCapacityContractDiagnostic[];
+}
+export interface DecisionAssignmentGraphCompileResult {
+    graph: DecisionAssignmentGraph;
+    diagnostics: AgentCapacityContractDiagnostic[];
+}
+export interface WorkdayModeSplitPolicy {
+    targetPercent: number;
+    minPercent?: number;
+    maxPercent?: number;
+    hardCapPercent?: number;
+}
+export interface WorkdayModeSplits {
+    planning?: WorkdayModeSplitPolicy;
+    acting?: WorkdayModeSplitPolicy;
+}
+export interface PlanningReservationMetadata {
+    source: 'provider_assignment_synthesis' | string;
+    planningSource: 'live_workday' | 'planning_input_request' | 'decision_estimation' | 'decision_review' | 'fallback_planning' | string;
+    activityType: AgentPlanningActivityType;
+    projectAgentClassId?: string | null;
+    agentSlug?: string | null;
+    workdayId?: string | null;
+    allocationSetId?: string | null;
+    modeSplitVersion?: string | null;
+}
+export interface ModeCapacityReservationAvailabilityInput {
+    teamId: string;
+    capacityProviderId: string;
+    projectId: string;
+    workDayId?: string | null;
+    allocationSetId?: string | null;
+    projectAgentClassId?: string | null;
+    agentSlug?: string | null;
+    mode: AgentExecutionMode;
+    activityType?: AgentPlanningActivityType | 'acting' | string | null;
+    reservedCredits: number;
+}
+export interface ModeCapacityReservationAvailabilityResult {
+    ok: boolean;
+    hold?: boolean;
+    reason?: string | null;
+    gates: Record<string, unknown>;
+}
+export declare const DEFAULT_WORKDAY_MODE_SPLITS: Required<WorkdayModeSplits>;
 export type AllocationSetStatus = 'draft' | 'active' | 'superseded' | 'archived';
 export type ProjectAgentClassStatus = 'active' | 'paused' | 'archived';
 export type ProviderAvailabilitySessionStatus = 'open' | 'draining' | 'closed' | 'expired';
@@ -728,6 +898,20 @@ export interface CapacitySettlementSummary {
     metadata?: Record<string, unknown>;
     createdAt?: string;
 }
+export declare function validateDecisionDependencySpec(dependency: DecisionDependencySpec, path?: string): AgentCapacityContractValidationResult;
+export declare function validateStructuredAgentEstimate(estimate: StructuredAgentEstimate): AgentCapacityContractValidationResult;
+export declare function validateDeliverableContract(contract: DeliverableContract): AgentCapacityContractValidationResult;
+export declare function validateDeliverableManifest(manifest: DeliverableManifest): AgentCapacityContractValidationResult;
+export declare function validateDecisionAssignmentGraph(graph: DecisionAssignmentGraph): AgentCapacityContractValidationResult;
+export declare function compileDecisionAssignmentGraphFromEstimates(input: {
+    id?: string;
+    teamId: string;
+    projectId: string;
+    decisionId: string;
+    version?: number;
+    estimates: StructuredAgentEstimate[];
+    compiledAt?: string | null;
+}): DecisionAssignmentGraphCompileResult;
 export declare function computeDecisionScopeHash(scope: unknown): string;
 export declare function isDecisionReadyForActing(status?: Pick<DecisionPlanningStatus, 'executionReadiness' | 'planningInputsStatus'> | null): boolean;
 export declare function isPlanningInputOpen(request: Pick<PlanningInputRequest, 'status'>): boolean;

package/dist/agent-capacity.js

@@ -1,3 +1,7 @@
+const DEFAULT_WORKDAY_MODE_SPLITS = {
+  planning: { targetPercent: 25, minPercent: 10, maxPercent: 40 },
+  acting: { targetPercent: 75, minPercent: 60, maxPercent: 90 }
+};
 const AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES = [
   "context_only",
   "workspace_write",
@@ -44,6 +48,208 @@ function firstArray(...values) {
   }
   return [];
 }
+function diagnostic(diagnostics, code, message, path, severity = "error") {
+  diagnostics.push({ severity, code, message, path });
+}
+function validateNonEmptyString(diagnostics, value, field, path = field) {
+  if (typeof value !== "string" || !value.trim()) diagnostic(diagnostics, "required_string_missing", `${field} is required.`, path);
+}
+function validateNonNegativeNumber(diagnostics, value, field, path = field) {
+  if (!Number.isFinite(Number(value)) || Number(value) < 0) {
+    diagnostic(diagnostics, "non_negative_number_required", `${field} must be a non-negative number.`, path);
+  }
+}
+function validationResult(diagnostics) {
+  return { ok: diagnostics.every((entry) => entry.severity !== "error"), diagnostics };
+}
+function dependencyToContractId(projectId, decisionId, dependency) {
+  const deliverable = dependency.deliverableType || dependency.capability || dependency.id;
+  return `${projectId}:${decisionId}:deliverable:${deliverable}`.replace(/[^a-zA-Z0-9:_-]+/gu, "-");
+}
+function edgeTypeForDependency(dependency) {
+  if (dependency.requiredBefore === "complete" || dependency.requiredBefore === "review") return "blocks-completion";
+  if (dependency.requiredBefore === "release") return "blocks-release";
+  return "blocks-start";
+}
+function validateDecisionDependencySpec(dependency, path = "dependency") {
+  const diagnostics = [];
+  validateNonEmptyString(diagnostics, dependency.id, "id", `${path}.id`);
+  if (!["artifact", "capability", "decision", "external-resource", "human-input"].includes(dependency.type)) {
+    diagnostic(diagnostics, "invalid_dependency_type", `Dependency ${dependency.id || "<unknown>"} has an invalid type.`, `${path}.type`);
+  }
+  if (!["start", "complete", "review", "release"].includes(dependency.requiredBefore)) {
+    diagnostic(diagnostics, "invalid_dependency_required_before", `Dependency ${dependency.id || "<unknown>"} has an invalid requiredBefore value.`, `${path}.requiredBefore`);
+  }
+  if (dependency.type === "artifact" && !dependency.deliverableType) diagnostic(diagnostics, "artifact_dependency_missing_deliverable_type", "Artifact dependencies must declare deliverableType.", `${path}.deliverableType`);
+  if (dependency.type === "capability" && !dependency.capability && !dependency.agentClass) diagnostic(diagnostics, "capability_dependency_missing_capability", "Capability dependencies must declare capability or agentClass.", `${path}.capability`);
+  if (dependency.type === "human-input") {
+    const policy = dependency.humanInputPolicy;
+    if (!policy || !["team-human", "any-human", "any-human-or-agent"].includes(policy.requiredFrom)) {
+      diagnostic(diagnostics, "human_input_policy_missing", "Human-input dependencies must declare a valid humanInputPolicy.requiredFrom.", `${path}.humanInputPolicy.requiredFrom`);
+    }
+  }
+  return validationResult(diagnostics);
+}
+function validateStructuredAgentEstimate(estimate) {
+  const diagnostics = [];
+  validateNonEmptyString(diagnostics, estimate.id, "id");
+  validateNonEmptyString(diagnostics, estimate.teamId, "teamId");
+  validateNonEmptyString(diagnostics, estimate.projectId, "projectId");
+  validateNonEmptyString(diagnostics, estimate.agentClass, "agentClass");
+  if (!estimate.decisionId && !estimate.proposalId) diagnostic(diagnostics, "estimate_missing_subject", "Structured estimates must reference a decisionId or proposalId.", "decisionId");
+  validateNonNegativeNumber(diagnostics, estimate.minCredits, "minCredits");
+  validateNonNegativeNumber(diagnostics, estimate.expectedCredits, "expectedCredits");
+  validateNonNegativeNumber(diagnostics, estimate.maxCredits, "maxCredits");
+  if (Number(estimate.minCredits) > Number(estimate.expectedCredits) || Number(estimate.expectedCredits) > Number(estimate.maxCredits)) {
+    diagnostic(diagnostics, "estimate_credit_bounds_invalid", "Estimate credit bounds must satisfy min <= expected <= max.", "expectedCredits");
+  }
+  if (!["low", "medium", "high"].includes(estimate.confidence)) diagnostic(diagnostics, "estimate_confidence_invalid", "Estimate confidence must be low, medium, or high.", "confidence");
+  if (!["low", "medium", "high"].includes(estimate.riskLevel)) diagnostic(diagnostics, "estimate_risk_level_invalid", "Estimate riskLevel must be low, medium, or high.", "riskLevel");
+  for (const [index, dependency] of (estimate.dependencies ?? []).entries()) {
+    diagnostics.push(...validateDecisionDependencySpec(dependency, `dependencies.${index}`).diagnostics);
+  }
+  return validationResult(diagnostics);
+}
+function validateDeliverableContract(contract) {
+  const diagnostics = [];
+  validateNonEmptyString(diagnostics, contract.id, "id");
+  validateNonEmptyString(diagnostics, contract.teamId, "teamId");
+  validateNonEmptyString(diagnostics, contract.projectId, "projectId");
+  validateNonEmptyString(diagnostics, contract.decisionId, "decisionId");
+  validateNonEmptyString(diagnostics, contract.deliverableType, "deliverableType");
+  if (!Array.isArray(contract.producerAgentClasses) || contract.producerAgentClasses.length === 0) diagnostic(diagnostics, "deliverable_contract_missing_producer", "Deliverable contracts must declare at least one producerAgentClass.", "producerAgentClasses");
+  if (!["required", "draft", "submitted", "approved", "rejected"].includes(contract.status)) diagnostic(diagnostics, "deliverable_contract_status_invalid", "Deliverable contract has an invalid status.", "status");
+  return validationResult(diagnostics);
+}
+function validateDeliverableManifest(manifest) {
+  const diagnostics = [];
+  validateNonEmptyString(diagnostics, manifest.id, "id");
+  validateNonEmptyString(diagnostics, manifest.deliverableContractId, "deliverableContractId");
+  validateNonEmptyString(diagnostics, manifest.projectId, "projectId");
+  validateNonEmptyString(diagnostics, manifest.decisionId, "decisionId");
+  if (!Array.isArray(manifest.producedRefs) || manifest.producedRefs.length === 0) diagnostic(diagnostics, "deliverable_manifest_missing_refs", "Deliverable manifests must map the contract to at least one produced content ref.", "producedRefs");
+  validateNonEmptyString(diagnostics, manifest.summary, "summary");
+  return validationResult(diagnostics);
+}
+function validateDecisionAssignmentGraph(graph) {
+  const diagnostics = [];
+  validateNonEmptyString(diagnostics, graph.id, "id");
+  validateNonEmptyString(diagnostics, graph.teamId, "teamId");
+  validateNonEmptyString(diagnostics, graph.projectId, "projectId");
+  validateNonEmptyString(diagnostics, graph.decisionId, "decisionId");
+  if (!Number.isInteger(graph.version) || graph.version < 1) diagnostic(diagnostics, "graph_version_invalid", "Decision assignment graph version must be a positive integer.", "version");
+  if (graph.compiledBy !== "api-control-plane") diagnostic(diagnostics, "graph_compiler_invalid", "Decision assignment graphs must be compiled by api-control-plane.", "compiledBy");
+  const nodeIds = new Set(graph.nodes.map((node) => node.id));
+  for (const [index, node] of graph.nodes.entries()) {
+    validateNonEmptyString(diagnostics, node.id, "node.id", `nodes.${index}.id`);
+    validateNonEmptyString(diagnostics, node.targetAgentClass, "node.targetAgentClass", `nodes.${index}.targetAgentClass`);
+    validateNonNegativeNumber(diagnostics, node.capacity.expectedCredits, "node.capacity.expectedCredits", `nodes.${index}.capacity.expectedCredits`);
+    validateNonNegativeNumber(diagnostics, node.capacity.maxCredits, "node.capacity.maxCredits", `nodes.${index}.capacity.maxCredits`);
+  }
+  for (const [index, edge] of graph.edges.entries()) {
+    if (!nodeIds.has(edge.fromNodeId)) diagnostic(diagnostics, "graph_edge_from_missing", `Edge ${index} references missing fromNodeId.`, `edges.${index}.fromNodeId`);
+    if (!nodeIds.has(edge.toNodeId)) diagnostic(diagnostics, "graph_edge_to_missing", `Edge ${index} references missing toNodeId.`, `edges.${index}.toNodeId`);
+  }
+  for (const [index, contract] of graph.deliverableContracts.entries()) {
+    diagnostics.push(...validateDeliverableContract(contract).diagnostics.map((entry) => ({ ...entry, path: `deliverableContracts.${index}${entry.path ? `.${entry.path}` : ""}` })));
+  }
+  return validationResult(diagnostics);
+}
+function compileDecisionAssignmentGraphFromEstimates(input) {
+  const diagnostics = [];
+  const estimates = [...input.estimates ?? []].sort((left, right) => left.agentClass.localeCompare(right.agentClass) || String(left.agentId ?? "").localeCompare(String(right.agentId ?? "")) || left.id.localeCompare(right.id));
+  for (const [index, estimate] of estimates.entries()) {
+    diagnostics.push(...validateStructuredAgentEstimate(estimate).diagnostics.map((entry) => ({ ...entry, path: `estimates.${index}${entry.path ? `.${entry.path}` : ""}` })));
+  }
+  const contractMap = /* @__PURE__ */ new Map();
+  const deliverableProducerNodes = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const edges = [];
+  for (const estimate of estimates) {
+    for (const dependency of estimate.dependencies.filter((entry) => entry.type === "artifact" && entry.deliverableType)) {
+      const contractId = dependencyToContractId(input.projectId, input.decisionId, dependency);
+      if (!contractMap.has(contractId)) {
+        const producerClass = dependency.agentClass || dependency.capability || dependency.deliverableType || "producer";
+        contractMap.set(contractId, {
+          id: contractId,
+          teamId: input.teamId,
+          projectId: input.projectId,
+          decisionId: input.decisionId,
+          deliverableType: dependency.deliverableType ?? dependency.id,
+          producerAgentClasses: [producerClass],
+          acceptanceCriteria: dependency.summary ? [dependency.summary] : [],
+          status: "required",
+          metadata: { sourceDependencyId: dependency.id }
+        });
+        const producerNodeId = `${contractId}:produce`;
+        deliverableProducerNodes.set(contractId, producerNodeId);
+        nodes.push({
+          id: producerNodeId,
+          decisionId: input.decisionId,
+          projectId: input.projectId,
+          targetAgentClass: producerClass,
+          activityType: "acting",
+          handler: null,
+          requiredCapabilities: uniqueStrings([dependency.capability ?? ""].filter(Boolean)),
+          requiredDeliverableContractIds: [],
+          inputRefs: [],
+          outputRequirements: [{ id: `${contractId}:output`, outputType: dependency.deliverableType ?? dependency.id, description: dependency.summary, required: true }],
+          capacity: { expectedCredits: 1, maxCredits: 1 },
+          status: "pending",
+          metadata: { deliverableContractId: contractId, generatedFromDependency: dependency.id }
+        });
+      }
+    }
+  }
+  for (const estimate of estimates) {
+    const nodeId = estimate.workUnitId || `estimate:${estimate.id}:work`;
+    const artifactDependencies = estimate.dependencies.filter((dependency) => dependency.type === "artifact" && dependency.deliverableType);
+    const requiredDeliverableContractIds = artifactDependencies.map((dependency) => dependencyToContractId(input.projectId, input.decisionId, dependency));
+    const inputRefs = estimate.dependencies.flatMap((dependency) => (dependency.contentRefs ?? []).map((ref) => ({ model: "note", collection: "notes", slug: ref, id: ref })));
+    nodes.push({
+      id: nodeId,
+      decisionId: input.decisionId,
+      projectId: input.projectId,
+      targetAgentClass: estimate.agentClass,
+      activityType: "acting",
+      handler: null,
+      requiredCapabilities: uniqueStrings(estimate.dependencies.map((dependency) => dependency.capability ?? dependency.agentClass ?? "").filter(Boolean)),
+      requiredDeliverableContractIds,
+      inputRefs,
+      outputRequirements: estimate.expectedOutputs,
+      capacity: { expectedCredits: estimate.expectedCredits, maxCredits: estimate.maxCredits },
+      status: "pending",
+      metadata: {
+        estimateId: estimate.id,
+        confidence: estimate.confidence,
+        riskLevel: estimate.riskLevel,
+        humanInputDependencies: estimate.dependencies.filter((dependency) => dependency.type === "human-input")
+      }
+    });
+    for (const dependency of artifactDependencies) {
+      const contractId = dependencyToContractId(input.projectId, input.decisionId, dependency);
+      const producerNodeId = deliverableProducerNodes.get(contractId);
+      if (producerNodeId) edges.push({ fromNodeId: producerNodeId, toNodeId: nodeId, edgeType: edgeTypeForDependency(dependency), reason: dependency.summary ?? dependency.deliverableType });
+    }
+  }
+  const graph = {
+    id: input.id ?? `${input.projectId}:${input.decisionId}:graph:v${input.version ?? 1}`,
+    teamId: input.teamId,
+    projectId: input.projectId,
+    decisionId: input.decisionId,
+    version: input.version ?? 1,
+    status: diagnostics.some((entry) => entry.severity === "error") ? "blocked" : "compiled",
+    estimateIds: estimates.map((estimate) => estimate.id),
+    deliverableContracts: [...contractMap.values()].sort((left, right) => left.id.localeCompare(right.id)),
+    nodes: nodes.sort((left, right) => left.id.localeCompare(right.id)),
+    edges: edges.sort((left, right) => left.fromNodeId.localeCompare(right.fromNodeId) || left.toNodeId.localeCompare(right.toNodeId) || left.edgeType.localeCompare(right.edgeType)),
+    compiledAt: input.compiledAt ?? null,
+    compiledBy: "api-control-plane",
+    metadata: { compiler: "compileDecisionAssignmentGraphFromEstimates" }
+  };
+  diagnostics.push(...validateDecisionAssignmentGraph(graph).diagnostics);
+  return { graph, diagnostics };
+}
 function booleanOrNull(value) {
   return typeof value === "boolean" ? value : null;
 }
@@ -1122,6 +1328,15 @@ function validateAgentKernelModeExecutionInput(input) {
       { retryable: true, metadata: { reservationId: capacity.reservationId ?? null, reservedCredits: capacity.reservedCredits ?? null } }
     );
   }
+  const activityType = String(record(decision.metadata).activityType ?? record(capacity.metadata).activityType ?? "");
+  const deterministicSystemReport = mode === "planning" && activityType === "reporting" && record(capacity.metadata).deterministicSystemReport === true;
+  if (mode === "planning" && !deterministicSystemReport && (!capacity.reservationId || Number(capacity.reservedCredits ?? 0) <= 0)) {
+    return createAgentKernelModeFallback(
+      "assignment_capacity_not_reserved",
+      `Assignment ${assignment.id} is missing reserved capacity for planning execution.`,
+      { retryable: true, metadata: { reservationId: capacity.reservationId ?? null, reservedCredits: capacity.reservedCredits ?? null, activityType: activityType || null } }
+    );
+  }
   if (mode === "acting" && !hasAcceptedCapacityPlanProvenance({ assignment, decisionInput: decision, capacityEnvelope: capacity })) {
     return createAgentKernelModeFallback(
       "assignment_capacity_plan_not_accepted",
@@ -1490,9 +1705,9 @@ function summarizeCapacityRuntimeDiagnostics(input) {
       }
     }
   }
-  const uniqueDiagnostics = Array.from(new Map(diagnostics.map((diagnostic) => [
-    `${diagnostic.assignmentId ?? "global"}:${diagnostic.code}`,
-    diagnostic
+  const uniqueDiagnostics = Array.from(new Map(diagnostics.map((diagnostic2) => [
+    `${diagnostic2.assignmentId ?? "global"}:${diagnostic2.code}`,
+    diagnostic2
   ])).values());
   return {
     projectId: input.projectId,
@@ -1555,9 +1770,11 @@ function validateCapacitySettlementInvariant(input) {
 }
 export {
   AGENT_ASSIGNMENT_WORKSPACE_ACCESS_MODES,
+  DEFAULT_WORKDAY_MODE_SPLITS,
   buildAgentCapacityPlanDraft,
   buildExecutionProviderAssignmentExplanation,
   buildProviderAssignmentExplanation,
+  compileDecisionAssignmentGraphFromEstimates,
   compileExecutionCapabilityDemand,
   compileExecutionCapabilitySupply,
   computeDecisionScopeHash,
@@ -1595,6 +1812,11 @@ export {
   validateAgentKernelModeExecutionInput,
   validateAgentKernelOutputs,
   validateCapacitySettlementInvariant,
+  validateDecisionAssignmentGraph,
+  validateDecisionDependencySpec,
+  validateDeliverableContract,
+  validateDeliverableManifest,
   validateProviderAssignmentCapabilityHandles,
+  validateStructuredAgentEstimate,
   validateTreeDxProxyHandle
 };

package/dist/guarantees/index.d.ts

@@ -82,6 +82,7 @@ export type TreeseedGuaranteeManifest = {
         optional?: string[];
     };
     notes?: string[];
+    dependsOnGuarantees?: string[];
 };
 export type TreeseedLoadedGuarantee = {
     sourcePath: string;
@@ -362,6 +363,7 @@ export declare function exportTreeseedGuaranteesJson(input: {
             optional?: string[];
         };
         notes?: string[];
+        dependsOnGuarantees?: string[];
         sourcePath: string;
     }[];
 };

package/dist/guarantees/index.js

@@ -155,6 +155,11 @@ function parseGuaranteeManifest(value, diagnostics, sourcePath) {
   if (subtype && !TAXONOMY_PATTERN.test(subtype)) diagnostics.push(diagnostic("error", "guarantee.invalid_subtype", `Guarantee subtype must be lowercase kebab-case: ${subtype}.`, "subtype", sourcePath));
   if (status && !KNOWN_STATUSES.has(status)) diagnostics.push(diagnostic("error", "guarantee.invalid_status", `Unsupported guarantee status "${status}".`, "status", sourcePath));
   if (surface && !KNOWN_SURFACES.has(surface)) diagnostics.push(diagnostic("error", "guarantee.invalid_surface", `Unsupported guarantee surface "${surface}".`, "surface", sourcePath));
+  const dependsOnGuarantees = Array.isArray(value.dependsOnGuarantees) ? value.dependsOnGuarantees.map((entry) => {
+    if (typeof entry === "string") return entry;
+    if (!isRecord(entry)) return "";
+    return typeof entry.ref === "string" && typeof entry.ownerPackage === "string" ? `${entry.ownerPackage}:${entry.ref}` : stringValue(entry.ref);
+  }).filter(Boolean) : [];
   const dependencies = isRecord(value.dependencies) ? value.dependencies : {};
   const actors = isRecord(value.actors) ? value.actors : {};
   const devices = isRecord(value.devices) ? value.devices : {};
@@ -212,7 +217,8 @@ function parseGuaranteeManifest(value, diagnostics, sourcePath) {
       required: stringArray(evidence.required),
       optional: stringArray(evidence.optional)
     },
-    notes: stringArray(value.notes)
+    notes: stringArray(value.notes),
+    dependsOnGuarantees
   };
   if (manifest.status === "active") {
     const hasContract = Boolean(manifest.scene?.required || manifest.api?.required || manifest.content?.required || manifest.audit?.required);
@@ -400,6 +406,13 @@ function validateTreeseedGuaranteeRegistry(input) {
       if (entry.manifest.journeyIndex && dep >= entry.manifest.journeyIndex) diagnostics.push(diagnostic("error", "guarantee.forward_journey_dependency", `Journey dependency ${dep} must be lower than ${entry.manifest.journeyIndex}.`, "dependencies.journeys", entry.sourcePath));
     }
   }
+  for (const entry of valid) {
+    for (const dep of entry.manifest.dependsOnGuarantees ?? []) {
+      const [ownerPackage, ref] = dep.includes(":") ? dep.split(/:(.+)/u).filter(Boolean) : ["", dep];
+      const match = valid.find((candidate) => (!ownerPackage || candidate.manifest.ownerPackage === ownerPackage) && candidate.manifest.status === "active" && (candidate.manifest.id === ref || allVerifierRefs(candidate.manifest).includes(ref)));
+      if (!match) diagnostics.push(diagnostic("error", "guarantee.missing_depends_on_guarantee", `Missing active guarantee dependency "${dep}".`, "dependsOnGuarantees", entry.sourcePath));
+    }
+  }
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const visit = (id, chain) => {

package/dist/hosting/graph.js

@@ -359,7 +359,7 @@ function buildProfileFromDeployConfig(input) {
         sourceCommit: sourcePolicy.sourceCommit,
         sourceRootDirectory: sourcePolicy.sourceRootDirectory,
         dockerfilePath: sourcePolicy.sourceMode === "git" ? service.railway?.dockerfilePath ?? null : null,
-        buildCommand: sourcePolicy.imageRef ? null : service.railway?.buildCommand ?? null,
+        buildCommand: sourcePolicy.imageRef || sourcePolicy.sourceMode === "git" && service.railway?.dockerfilePath ? null : service.railway?.buildCommand ?? null,
         startCommand: sourcePolicy.imageRef ? null : service.railway?.startCommand ?? null,
         healthcheckPath: service.railway?.healthcheckPath ?? null,
         runtimeMode: service.railway?.runtimeMode ?? null,

package/dist/local-dev/managed-dev.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { closeSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, appendFileSync, openSync } from "node:fs";
 import { resolve } from "node:path";
 function splitSurfaces(value) {
@@ -13,6 +13,44 @@ function pidAlive(pid) {
     return false;
   }
 }
+function portListenerPids(port) {
+  if (!port || !Number.isFinite(port)) return [];
+  try {
+    const output = execFileSync("lsof", [`-tiTCP:${port}`, "-sTCP:LISTEN", "-n", "-P"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.split(/\r?\n/u).map((entry) => Number(entry.trim())).filter((pid) => Number.isInteger(pid) && pid > 0);
+  } catch {
+    return [];
+  }
+}
+async function waitForPidsToExit(pids, timeoutMs = 3e3) {
+  const startedAt = Date.now();
+  while (pids.some((pid) => pidAlive(pid)) && Date.now() - startedAt < timeoutMs) {
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 100));
+  }
+}
+async function stopConflictingPortListeners(spec, allowedPid = null) {
+  const conflicts = portListenerPids(spec.port).filter((pid) => pid !== process.pid && pid !== allowedPid);
+  if (conflicts.length === 0) return [];
+  for (const pid of conflicts) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  await waitForPidsToExit(conflicts);
+  const remaining = conflicts.filter((pid) => pidAlive(pid));
+  for (const pid of remaining) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  await waitForPidsToExit(remaining, 1e3);
+  return conflicts;
+}
 function scopeId(tenantRoot) {
   return Buffer.from(tenantRoot).toString("base64url").slice(0, 32);
 }
@@ -240,7 +278,7 @@ async function instanceFromSpecWithHealth(spec) {
   const instance = instanceFromSpec(spec);
   const healthStatus = await checkHealth(spec);
   const healthy = healthStatus.length === 0 || healthStatus.every((entry) => entry.ok);
-  const running = healthStatus.length > 0 ? healthy : instance.running;
+  const running = healthStatus.length > 0 ? instance.running && healthy : instance.running;
   return {
     ...instance,
     healthStatus,
@@ -270,7 +308,7 @@ function stopSpec(spec) {
   rmSync(spec.instancePath, { force: true });
   return instance;
 }
-async function startSpec(spec, force = false) {
+async function startSpec(spec, force = false, forceConflicts = false) {
   const existing = instanceFromSpec(spec);
   if (existing.running && !force) {
     return existing;
@@ -278,6 +316,9 @@ async function startSpec(spec, force = false) {
   if (existing.running && force) {
     stopSpec(spec);
   }
+  if (forceConflicts) {
+    await stopConflictingPortListeners(spec, existing.pid);
+  }
   mkdirSync(resolve(spec.pidPath, ".."), { recursive: true });
   mkdirSync(resolve(spec.instancePath, ".."), { recursive: true });
   mkdirSync(resolve(spec.logPath, ".."), { recursive: true });
@@ -311,7 +352,7 @@ async function startTreeseedManagedDev(options = {}) {
   const plan = createTreeseedIntegratedDevPlan(options);
   const instances = [];
   for (const spec of plan.processes) {
-    await startSpec(spec, options.force === true);
+    await startSpec(spec, options.force === true, options.forceConflicts === true);
     instances.push(await waitForHealthySpec(spec));
   }
   return { ok: instances.every((entry) => entry.running), action: "start", plan, instances };

package/dist/operations/repository-operations.js

@@ -50,19 +50,30 @@ const CONTENT_DEFAULTS = {
     idPrefix: "agent",
     extension: "mdx",
     fields: {
+      slug: "",
+      title: "",
       name: "",
-      handler: "plan",
+      agentClass: "general",
       enabled: true,
       operator: "TreeSeed platform",
       runtimeStatus: "active",
       capabilities: [],
       tags: ["agent"],
-      systemPrompt: "Use the core objective as the first context message. Keep work observable, governed, and grounded in project content.",
-      persona: "Helpful, careful, and accountable.",
-      triggers: [{ type: "message", messageTypes: [] }],
-      permissions: [],
-      execution: { provider: "codex", model: "gpt-5.5", approvalPolicy: "never", sandboxMode: "read_only", reasoningEffort: "medium" },
-      outputs: {}
+      identity: {
+        purpose: "",
+        responsibilities: [],
+        durableInstructions: "Keep work observable, governed, and grounded in project content."
+      },
+      activityProfiles: {
+        planning: {
+          enabled: true,
+          handler: "writer",
+          prompt: { system: "Use TreeDX-backed content tools and stay scoped to this project." },
+          branchPolicy: { kind: "read-only", base: "main" },
+          tools: { allowed: ["treeseed.content.query", "treeseed.content.read"] },
+          outputs: { messageTypes: [], modelMutations: [] }
+        }
+      }
     },
     body: "Describe this agent role, operating boundaries, and expected outputs."
   }

package/dist/operations/services/deployment-readiness.js

@@ -127,7 +127,11 @@ function collectTreeseedDeploymentReadiness(options) {
     checks.push(check("hosting:api:projectGroup", api.projectGroupId, "treeseed-control-plane", "API project group targets the Treeseed control plane.", "Bind services.api to the treeseed-control-plane project group.", "projectGroupId"));
     checks.push(check("hosting:api:rootDir", api.config?.rootDir, expectedApiUnitRoot, "API effective rootDir points at the API package.", "Set services.api.rootDir and services.api.railway.rootDir relative to the owning API manifest.", "rootDir"));
     if (environment === "local") {
-      checks.push(check("hosting:api:buildCommand", api.config?.buildCommand, "npm run build", "API build command is package-local.", 'Set services.api.railway.buildCommand to "npm run build".', "buildCommand"));
+      if (api.config?.dockerfilePath) {
+        checks.push(check("hosting:api:dockerfilePath", api.config.dockerfilePath, "/Dockerfile.api", "API local deploy uses the same Dockerfile build contract as staging.", "Set services.api.railway.dockerfilePath to /Dockerfile.api.", "dockerfilePath"));
+      } else {
+        checks.push(check("hosting:api:buildCommand", api.config?.buildCommand, "npm run build", "API build command is package-local.", 'Set services.api.railway.buildCommand to "npm run build".', "buildCommand"));
+      }
       checks.push(check("hosting:api:startCommand", api.config?.startCommand, "npm run start:api", "API start command is package-local.", 'Set services.api.railway.startCommand to "npm run start:api".', "startCommand"));
     } else if (environment === "staging") {
       checks.push(check("hosting:api:sourceMode", api.config?.sourceMode, "git", "API staging deploy uses Railway Git source builds.", "Set services.api.railway.sourceMode to git.", "sourceMode"));
@@ -154,7 +158,11 @@ function collectTreeseedDeploymentReadiness(options) {
     checks.push(check("hosting:operationsRunner:projectGroup", runner.projectGroupId, "treeseed-control-plane", "Runner project group targets the Treeseed control plane.", "Bind services.operationsRunner to the treeseed-control-plane project group.", "projectGroupId"));
     checks.push(check("hosting:operationsRunner:rootDir", runner.config?.rootDir, expectedRunnerUnitRoot, "Runner effective rootDir points at the API package.", "Set services.operationsRunner.rootDir and services.operationsRunner.railway.rootDir relative to the owning API manifest.", "rootDir"));
     if (environment === "local") {
-      checks.push(check("hosting:operationsRunner:buildCommand", runner.config?.buildCommand, "npm run build", "Runner build command is package-local.", 'Set services.operationsRunner.railway.buildCommand to "npm run build".', "buildCommand"));
+      if (runner.config?.dockerfilePath) {
+        checks.push(check("hosting:operationsRunner:dockerfilePath", runner.config.dockerfilePath, "/Dockerfile.operations-runner", "Runner local deploy uses the same Dockerfile build contract as staging.", "Set services.operationsRunner.railway.dockerfilePath to /Dockerfile.operations-runner.", "dockerfilePath"));
+      } else {
+        checks.push(check("hosting:operationsRunner:buildCommand", runner.config?.buildCommand, "npm run build", "Runner build command is package-local.", 'Set services.operationsRunner.railway.buildCommand to "npm run build".', "buildCommand"));
+      }
       checks.push(check("hosting:operationsRunner:startCommand", runner.config?.startCommand, "npm run start:runner", "Runner start command is package-local.", 'Set services.operationsRunner.railway.startCommand to "npm run start:runner".', "startCommand"));
     } else if (environment === "staging") {
       checks.push(check("hosting:operationsRunner:sourceMode", runner.config?.sourceMode, "git", "Runner staging deploy uses Railway Git source builds.", "Set services.operationsRunner.railway.sourceMode to git.", "sourceMode"));

package/dist/operations/services/railway-deploy.js

@@ -713,7 +713,7 @@ function configuredRailwayServicesForConfig(tenantRoot, scope, deployConfig, app
         rootDir: serviceRoot,
         publicBaseUrl,
         railwayEnvironment,
-        buildCommand: resolvedImageRef ? null : service.railway?.buildCommand ?? null,
+        buildCommand: resolvedImageRef || sourcePolicy.sourceMode === "git" && service.railway?.dockerfilePath ? null : service.railway?.buildCommand ?? null,
         startCommand: isCapacityProviderService ? null : resolvedImageRef ? null : service.railway?.startCommand ?? null,
         imageRef: resolvedImageRef,
         sourceMode: sourcePolicy.sourceMode,

package/dist/operations/services/template-registry.js

@@ -70,8 +70,7 @@ function listTemplateArtifactIds() {
 }
 const LOCAL_STARTER_ID_TO_DIRECTORY = {
   "research": "research",
-  "engineering": "engineering",
-  "information-hub": "information-hub"
+  "engineering": "engineering"
 };
 function localStartersRoot() {
   return resolve(cliPackageRoot, "..", "..", "starters");

package/dist/platform/desired-state.js

@@ -636,7 +636,7 @@ function localDevelopmentResources(tenantRoot, environment, localContent) {
         },
         volumes: [{ name: "treeseed-local-treedx-data", mountPath: "/data", sharedLocalOnly: true }],
         healthChecks: [
-          { id: "treedx-api", kind: "http", url: "http://127.0.0.1:4000/api/v1/health" }
+          { id: "treedx-api", kind: "http", url: "http://127.0.0.1:4000/api/v1/health", attempts: 240, intervalMs: 2e3 }
         ]
       },
       source: { type: "package-adapter", id: "treedx" }

package/dist/reconcile/builtin-adapters.js

@@ -782,6 +782,9 @@ function buildLocalDockerComposeAdapter() {
     },
     diff(input) {
       if (!input.observed.exists) return { action: "blocked", reasons: input.observed.warnings, before: input.observed.live, after: input.unit.spec };
+      if (input.unit.spec.forceRecreate === true) {
+        return { action: "update", reasons: ["compose force recreate requested"], before: input.observed.live, after: input.unit.spec };
+      }
       return input.observed.status === "ready" ? noopDiff() : { action: "create", reasons: ["compose services are not running"], before: input.observed.live, after: input.unit.spec };
     },
     apply(input) {
@@ -799,7 +802,7 @@ function buildLocalDockerComposeAdapter() {
         env,
         profiles: localComposeProfiles(input),
         buildPolicy: localComposeBuildPolicy(input),
-        action: "up"
+        action: input.unit.spec.forceRecreate === true ? "restart" : "up"
       });
       if (!result.ok) {
         throw new Error(result.stderr.trim() || result.stdout.trim() || "docker compose up failed");
@@ -811,7 +814,9 @@ function buildLocalDockerComposeAdapter() {
       const checks = [];
       for (const healthCheck of healthChecks) {
         if (healthCheck.kind === "http" && typeof healthCheck.url === "string") {
-          const health = await checkHttpHealthWithRetry(healthCheck.url);
+          const attempts = typeof healthCheck.attempts === "number" && Number.isFinite(healthCheck.attempts) ? Math.max(1, Math.floor(healthCheck.attempts)) : void 0;
+          const intervalMs = typeof healthCheck.intervalMs === "number" && Number.isFinite(healthCheck.intervalMs) ? Math.max(100, Math.floor(healthCheck.intervalMs)) : void 0;
+          const health = await checkHttpHealthWithRetry(healthCheck.url, attempts, intervalMs);
           checks.push(verificationCheck(String(healthCheck.id ?? healthCheck.url), `HTTP health ${healthCheck.url}`, "api", {
             exists: health.ok,
             configured: true,
@@ -1235,6 +1240,9 @@ function buildLocalProcessAdapter() {
       };
     },
     diff(input) {
+      if (input.unit.spec.action === "restart") {
+        return { action: "update", reasons: ["local process restart requested"], before: input.observed.live, after: input.unit.spec };
+      }
       return input.observed.status === "ready" ? noopDiff() : { action: "create", reasons: ["local process is not reported ready"], before: input.observed.live, after: input.unit.spec };
     },
     async apply(input) {

package/dist/treeseed/template-catalog/catalog.fixture.json

@@ -368,190 +368,6 @@
       "relatedKnowledge": [],
       "relatedObjectives": []
     },
-    {
-      "id": "information-hub",
-      "displayName": "TreeSeed Information Hub",
-      "description": "First-party TreeSeed starter for recurring information retrieval, distillation, and downstream distribution.",
-      "summary": "An information distribution starter for retrieving updates over time, distilling derived knowledge, and packaging it for downstream projects.",
-      "status": "live",
-      "featured": true,
-      "category": "starter",
-      "audience": [
-        "curators",
-        "maintainers"
-      ],
-      "tags": [
-        "starter",
-        "information-hub",
-        "distribution",
-        "knowledge-packs",
-        "agents"
-      ],
-      "publisher": {
-        "id": "treeseed",
-        "name": "TreeSeed",
-        "url": "https://treeseed.dev"
-      },
-      "publisherVerified": true,
-      "templateVersion": "1.0.0",
-      "templateApiVersion": 1,
-      "minCliVersion": "0.1.1",
-      "minCoreVersion": "0.1.2",
-      "fulfillment": {
-        "mode": "git",
-        "source": {
-          "kind": "git",
-          "repoUrl": "https://github.com/treeseed-templates/information-hub.git",
-          "directory": ".",
-          "ref": "staging",
-          "integrity": "pending-external-repo"
-        },
-        "hooksPolicy": "builtin_only",
-        "supportsReconcile": true
-      },
-      "offer": {
-        "priceModel": "free",
-        "license": "AGPL-3.0-only",
-        "support": "community"
-      },
-      "launchRequirements": {
-        "version": 1,
-        "hosts": [
-          {
-            "kind": "host",
-            "key": "sourceRepository",
-            "type": "repository",
-            "required": true,
-            "compatibleProviders": [
-              "github"
-            ],
-            "displayName": "Source repository",
-            "purpose": "Create and push the generated information hub project repository.",
-            "defaultSelection": "team-default",
-            "configWrites": [
-              {
-                "target": "treeseed.site.yaml",
-                "path": "hosting.hostBindings.sourceRepository.provider",
-                "valueFrom": "selectedHost.provider"
-              },
-              {
-                "target": "treeseed.site.yaml",
-                "path": "hosting.hostBindings.sourceRepository.owner",
-                "valueFrom": "selectedHost.github.owner"
-              },
-              {
-                "target": "treeseed.site.yaml",
-                "path": "hosting.hostBindings.sourceRepository.repository",
-                "valueFrom": "derived.repositoryName"
-              }
-            ],
-            "environmentWrites": [
-              {
-                "env": "GITHUB_TOKEN",
-                "valueFrom": "selectedHost.token",
-                "targets": [
-                  "github-secret"
-                ],
-                "scopes": [
-                  "staging",
-                  "prod"
-                ],
-                "sensitivity": "secret"
-              }
-            ]
-          },
-          {
-            "kind": "host",
-            "key": "publicWeb",
-            "type": "web",
-            "required": true,
-            "compatibleProviders": [
-              "cloudflare"
-            ],
-            "displayName": "Public web host",
-            "purpose": "Deploy the information hub site, previews, content storage, and web runtime resources.",
-            "defaultSelection": "managed",
-            "configWrites": [
-              {
-                "target": "treeseed.site.yaml",
-                "path": "hosting.hostBindings.publicWeb.provider",
-                "valueFrom": "selectedHost.provider"
-              },
-              {
-                "target": "treeseed.site.yaml",
-                "path": "surfaces.web.provider",
-                "valueFrom": "selectedHost.provider"
-              },
-              {
-                "target": "treeseed.site.yaml",
-                "path": "surfaces.web.environments.prod.domain",
-                "valueFrom": "launchInput.domains.productionDomain",
-                "writeWhen": "host-selected"
-              },
-              {
-                "target": "treeseed.site.yaml",
-                "path": "surfaces.web.environments.staging.domain",
-                "valueFrom": "launchInput.domains.stagingDomain",
-                "writeWhen": "host-selected"
-              }
-            ],
-            "environmentWrites": [
-              {
-                "env": "TREESEED_PUBLIC_WEB_PROVIDER",
-                "valueFrom": "selectedHost.provider",
-                "targets": [
-                  "github-variable",
-                  "cloudflare-var"
-                ],
-                "scopes": [
-                  "staging",
-                  "prod"
-                ],
-                "sensitivity": "plain"
-              }
-            ]
-          },
-          {
-            "kind": "host",
-            "key": "transactionalEmail",
-            "type": "email",
-            "required": false,
-            "compatibleProviders": [
-              "smtp"
-            ],
-            "displayName": "Transactional email",
-            "purpose": "Send form, account, and information hub project notification email.",
-            "defaultSelection": "managed",
-            "configWrites": [
-              {
-                "target": "treeseed.site.yaml",
-                "path": "hosting.hostBindings.transactionalEmail.provider",
-                "valueFrom": "selectedHost.provider",
-                "writeWhen": "host-selected"
-              }
-            ],
-            "environmentWrites": [
-              {
-                "env": "SMTP_HOST",
-                "valueFrom": "selectedHost.smtpHost",
-                "targets": [
-                  "github-secret",
-                  "railway-secret"
-                ],
-                "scopes": [
-                  "staging",
-                  "prod"
-                ],
-                "sensitivity": "secret"
-              }
-            ]
-          }
-        ]
-      },
-      "relatedBooks": [],
-      "relatedKnowledge": [],
-      "relatedObjectives": []
-    },
     {
       "id": "market-control-plane",
       "displayName": "TreeSeed Market Control Plane",

package/dist/types/agents.d.ts

@@ -2,7 +2,9 @@ export declare const AGENT_TRIGGER_KINDS: readonly ["schedule", "message", "foll
 export declare const AGENT_PERMISSION_OPERATIONS: readonly ["get", "read", "search", "follow", "pick", "create", "update"];
 export declare const AGENT_MESSAGE_STATUSES: readonly ["pending", "claimed", "completed", "failed", "dead_letter"];
 export declare const AGENT_RUN_STATUSES: readonly ["running", "completed", "failed", "waiting"];
-export declare const AGENT_HANDLER_KINDS: readonly ["planner", "architect", "engineer", "notifier", "researcher", "reviewer", "releaser"];
+export declare const AGENT_HANDLER_KINDS: readonly ["writer", "actor", "estimate", "releaser", "reporter"];
+export declare const AGENT_ACTIVITY_TYPES: readonly ["planning", "estimating", "acting", "reviewing", "reporting"];
+export declare const ENGINEERING_HANDLER_KINDS: readonly ["writer", "actor", "estimate", "releaser", "reporter"];
 export declare const AGENT_CLI_ALLOW_TOOLS: readonly ["shell(git)", "shell(npm)", "web"];
 export declare const EXECUTION_RESOURCE_NEED_KINDS: readonly ["repository", "treedx_workspace", "workflow", "secret", "external_issue", "external_job"];
 export declare const EXECUTION_PROVIDER_KINDS: readonly ["ai_model", "human_issue_queue", "deterministic_workflow", "local_process"];
@@ -14,6 +16,8 @@ export type AgentPermissionOperation = (typeof AGENT_PERMISSION_OPERATIONS)[numb
 export type AgentMessageStatus = (typeof AGENT_MESSAGE_STATUSES)[number];
 export type AgentRunStatus = (typeof AGENT_RUN_STATUSES)[number];
 export type AgentHandlerKind = string;
+export type AgentActivityType = (typeof AGENT_ACTIVITY_TYPES)[number];
+export type EngineeringHandlerKind = (typeof ENGINEERING_HANDLER_KINDS)[number];
 export type AgentCliAllowTool = (typeof AGENT_CLI_ALLOW_TOOLS)[number];
 export type ExecutionResourceNeedKind = (typeof EXECUTION_RESOURCE_NEED_KINDS)[number] | string;
 export type ExecutionProviderKind = (typeof EXECUTION_PROVIDER_KINDS)[number] | string;
@@ -69,6 +73,7 @@ export interface AgentOutputContract {
 }
 export interface AgentToolPolicy {
     allowed: string[];
+    denied?: string[];
 }
 export interface AgentContentScope {
     models: string[];
@@ -84,6 +89,94 @@ export interface AgentContentAccessPolicy {
         allowed: boolean;
     };
 }
+export type AgentBranchPolicy = {
+    kind: 'read-only';
+    base: 'main' | 'staging';
+} | {
+    kind: 'main-planning-content';
+    base: 'main';
+} | {
+    kind: 'staging-content';
+    base: 'staging';
+} | {
+    kind: 'assignment-feature';
+    base: 'staging';
+    target: 'staging';
+    prefix?: string;
+    branchNameTemplate?: string;
+    worktree?: 'new' | 'reuse';
+    updateBaseBeforeRun?: boolean;
+    mergeTargetBeforeSave?: boolean;
+} | {
+    kind: 'staging-release';
+    base: 'staging';
+    target: 'main';
+};
+export type AgentQuestionAnswerPolicy = {
+    kind: 'team-human';
+    teamId?: string;
+    requiredRoles?: string[];
+} | {
+    kind: 'human-or-agent';
+    teamId?: string;
+    allowedRoles?: string[];
+    allowedAgentClasses?: string[];
+} | {
+    kind: 'specific-human';
+    teamMemberId: string;
+} | {
+    kind: 'specific-agent';
+    projectId: string;
+    agentSlug: string;
+};
+export interface AgentQuestionPolicy {
+    defaultAnswerPolicy?: AgentQuestionAnswerPolicy;
+    blockExecutionWhenCreated?: boolean;
+}
+export interface AgentActivityPromptConfig {
+    system: string;
+    task?: string;
+    templates?: Record<string, string>;
+}
+export interface AgentActivityExecutionConfig {
+    providerPreference?: string[];
+    maxRuntimeSeconds?: number;
+    maxRetries?: number;
+    verificationRequired?: boolean;
+}
+export interface AgentActivityProfile {
+    enabled: boolean;
+    handler: EngineeringHandlerKind;
+    prompt: AgentActivityPromptConfig;
+    branchPolicy: AgentBranchPolicy;
+    contentAccess?: AgentContentAccessPolicy;
+    tools: AgentToolPolicy;
+    outputs: AgentOutputContract;
+    questionPolicy?: AgentQuestionPolicy;
+    execution?: AgentActivityExecutionConfig;
+}
+export interface AgentCapability {
+    id: string;
+    description?: string;
+    produces?: string[];
+    requires?: string[];
+    reviews?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface AgentDefinitionIdentity {
+    purpose: string;
+    responsibilities: string[];
+    durableInstructions: string;
+}
+export interface AgentDefinition {
+    slug: string;
+    title: string;
+    agentClass: string;
+    template?: string;
+    identity: AgentDefinitionIdentity;
+    capabilities: AgentCapability[];
+    activityProfiles: Partial<Record<AgentActivityType, AgentActivityProfile>>;
+}
 export interface AgentExecutionConfig {
     provider?: string;
     model?: string;
@@ -176,7 +269,7 @@ export interface AgentWorkPackageConstraints {
     maxAttempts?: number | null;
     metadata?: Record<string, unknown>;
 }
-export type AgentHandlerAlgorithmKind = 'plan' | 'research' | 'act' | 'review' | 'report';
+export type AgentHandlerAlgorithmKind = EngineeringHandlerKind;
 export type AgentWorkPackageKind = AgentHandlerAlgorithmKind | string;
 export interface AgentInputSelector {
     source: string;
@@ -332,9 +425,14 @@ export interface AgentCliOptions {
 export interface AgentRuntimeSpec {
     slug: string;
     handler: AgentHandlerKind;
+    activityType?: AgentActivityType;
+    activityProfiles?: Partial<Record<AgentActivityType, AgentActivityProfile>>;
+    branchPolicy?: AgentBranchPolicy;
+    questionPolicy?: AgentQuestionPolicy;
+    identity?: AgentDefinitionIdentity;
     projectAgentClassId?: string;
     projectAgentClassSlug?: string;
-    handlerConfig?: AgentHandlerConfig;
+    activityConfig?: AgentHandlerConfig;
     enabled: boolean;
     systemPrompt: string;
     persona: string;

package/dist/types/agents.js

@@ -17,13 +17,25 @@ const AGENT_MESSAGE_STATUSES = [
 ];
 const AGENT_RUN_STATUSES = ["running", "completed", "failed", "waiting"];
 const AGENT_HANDLER_KINDS = [
-  "planner",
-  "architect",
-  "engineer",
-  "notifier",
-  "researcher",
-  "reviewer",
-  "releaser"
+  "writer",
+  "actor",
+  "estimate",
+  "releaser",
+  "reporter"
+];
+const AGENT_ACTIVITY_TYPES = [
+  "planning",
+  "estimating",
+  "acting",
+  "reviewing",
+  "reporting"
+];
+const ENGINEERING_HANDLER_KINDS = [
+  "writer",
+  "actor",
+  "estimate",
+  "releaser",
+  "reporter"
 ];
 const AGENT_CLI_ALLOW_TOOLS = [
   "shell(git)",
@@ -67,12 +79,14 @@ const EXECUTION_PROVIDER_QUOTA_VISIBILITIES = [
   "exact"
 ];
 export {
+  AGENT_ACTIVITY_TYPES,
   AGENT_CLI_ALLOW_TOOLS,
   AGENT_HANDLER_KINDS,
   AGENT_MESSAGE_STATUSES,
   AGENT_PERMISSION_OPERATIONS,
   AGENT_RUN_STATUSES,
   AGENT_TRIGGER_KINDS,
+  ENGINEERING_HANDLER_KINDS,
   EXECUTION_PROVIDER_KINDS,
   EXECUTION_PROVIDER_PRESSURE_STATES,
   EXECUTION_PROVIDER_QUOTA_VISIBILITIES,

package/dist/workflow/operations.js

@@ -1717,11 +1717,13 @@ function hostedWorkflowForSavedRepository(root, repo) {
   if (repo.branch === STAGING_BRANCH && existsSync(resolve(repo.path, "treeseed.site.yaml")) && workflowFileExists(repo.path, "deploy.yml")) {
     return "deploy.yml";
   }
-  return "verify.yml";
+  if (workflowFileExists(repo.path, "verify.yml")) return "verify.yml";
+  return null;
 }
 function gatesForSavedRepositoryReports(root, reports) {
-  return reports.filter((repo) => repo.pushed && repo.commitSha && repo.branch && (repo.committed || repo.tagName)).map((repo) => {
+  return reports.filter((repo) => repo.pushed && repo.commitSha && repo.branch && (repo.committed || repo.tagName)).flatMap((repo) => {
     const workflow = hostedWorkflowForSavedRepository(root, repo);
+    if (!workflow) return [];
     const gate = {
       name: repo.name,
       repoPath: repo.path,
@@ -1729,7 +1731,7 @@ function gatesForSavedRepositoryReports(root, reports) {
       branch: String(repo.branch),
       headSha: String(repo.commitSha)
     };
-    return /^deploy(?:[-.]|$)/u.test(workflow) ? hostedDeployGate(gate) : gate;
+    return [/^deploy(?:[-.]|$)/u.test(workflow) ? hostedDeployGate(gate) : gate];
   });
 }
 function packageHostedVerifyWorkflow(adapter) {

package/drizzle/market/0015_agent_decision_assignment_graphs.sql

@@ -0,0 +1,60 @@
+CREATE TABLE IF NOT EXISTS "structured_agent_estimates" (
+	"id" text PRIMARY KEY NOT NULL,
+	"team_id" text NOT NULL,
+	"project_id" text NOT NULL,
+	"decision_id" text,
+	"proposal_id" text,
+	"work_unit_id" text,
+	"agent_class" text NOT NULL,
+	"agent_id" text,
+	"status" text DEFAULT 'submitted' NOT NULL,
+	"estimate_json" text NOT NULL,
+	"metadata_json" text DEFAULT '{}' NOT NULL,
+	"created_at" text NOT NULL,
+	"accepted_at" text,
+	"rejected_at" text
+);
+CREATE INDEX IF NOT EXISTS "idx_structured_agent_estimates_decision" ON "structured_agent_estimates" ("decision_id","status","created_at");
+
+CREATE TABLE IF NOT EXISTS "decision_assignment_graphs" (
+	"id" text PRIMARY KEY NOT NULL,
+	"team_id" text NOT NULL,
+	"project_id" text NOT NULL,
+	"decision_id" text NOT NULL,
+	"version" integer NOT NULL,
+	"status" text NOT NULL,
+	"active" integer DEFAULT 0 NOT NULL,
+	"graph_json" text NOT NULL,
+	"metadata_json" text DEFAULT '{}' NOT NULL,
+	"compiled_at" text,
+	"created_at" text NOT NULL,
+	"updated_at" text NOT NULL
+);
+CREATE INDEX IF NOT EXISTS "idx_decision_assignment_graphs_decision" ON "decision_assignment_graphs" ("decision_id","active","version");
+
+CREATE TABLE IF NOT EXISTS "deliverable_contracts" (
+	"id" text PRIMARY KEY NOT NULL,
+	"team_id" text NOT NULL,
+	"project_id" text NOT NULL,
+	"decision_id" text NOT NULL,
+	"deliverable_type" text NOT NULL,
+	"status" text NOT NULL,
+	"contract_json" text NOT NULL,
+	"metadata_json" text DEFAULT '{}' NOT NULL,
+	"created_at" text NOT NULL,
+	"updated_at" text NOT NULL
+);
+CREATE INDEX IF NOT EXISTS "idx_deliverable_contracts_decision" ON "deliverable_contracts" ("decision_id","status","deliverable_type");
+
+CREATE TABLE IF NOT EXISTS "deliverable_manifests" (
+	"id" text PRIMARY KEY NOT NULL,
+	"deliverable_contract_id" text NOT NULL,
+	"project_id" text NOT NULL,
+	"decision_id" text NOT NULL,
+	"ready_for_review" integer DEFAULT 0 NOT NULL,
+	"manifest_json" text NOT NULL,
+	"metadata_json" text DEFAULT '{}' NOT NULL,
+	"submitted_at" text,
+	"created_at" text NOT NULL
+);
+CREATE INDEX IF NOT EXISTS "idx_deliverable_manifests_contract" ON "deliverable_manifests" ("deliverable_contract_id","submitted_at");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.12.40",
+  "version": "0.12.42",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {