@treeseed/sdk 0.12.41 → 0.12.43

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."
   }