@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/agent-capacity/contracts/support/operator-surface.js

@@ -1,187 +0,0 @@
-import { CAPACITY_CONFIGURATION_DESCRIPTORS } from "../configuration/configuration.js";
-function capability(id, cliAction, kind, apiRouteIds = [], options = {}) {
-  const secretConfirmation = options.secretConfirmation === true;
-  return {
-    id,
-    cliAction,
-    kind,
-    apiRouteIds,
-    access: options.access ?? accessFor(id, kind),
-    mutationMode: kind === "mutation" ? "plan-execute" : kind === "plan" ? "plan-only" : kind === "local-runtime" ? "local-live" : "none",
-    confirmation: secretConfirmation ? "yes" : kind === "mutation" ? "execute" : "none",
-    uiAvailable: !id.startsWith("provider.identity.") && !id.startsWith("provider.runtime."),
-    agentVisibility: id.startsWith("provider.") ? "none" : "operator",
-    ...options
-  };
-}
-function accessFor(id, kind) {
-  if (id.startsWith("provider.")) {
-    if (id === "provider.join" || id === "provider.registration-status" || id === "provider.credential-exchange") return "provider-proof";
-    if (id === "provider.identity.rotate" || id === "provider.credential-rotate" || id === "provider.connections.leave" || id === "provider.offer.apply") return "provider-access-token";
-    return "provider-owner-local";
-  }
-  if (id.startsWith("agent-classes.")) return kind === "read" ? "project-read" : "project-manage";
-  if (id.startsWith("capacity-plans.")) return kind === "read" ? "project-read" : "project-manage";
-  if (id === "workdays.tick") return "team-manage";
-  if (id.startsWith("workdays.")) return kind === "read" ? "project-read" : "project-manage";
-  if (id.startsWith("registration-key.")) return "team-manage";
-  if (id.startsWith("registration-requests.") || id.startsWith("memberships.") || id.startsWith("credentials.")) return kind === "read" ? "team-read" : "team-manage";
-  if (id.startsWith("grants.") || id.startsWith("allocations.")) return kind === "read" ? "team-read" : "team-manage";
-  if (id.startsWith("assignments.") || id.startsWith("reservations.") || id.startsWith("usage.") || id.startsWith("ledger.") || id.startsWith("audit.")) return kind === "read" || kind === "export" ? "team-read" : "team-manage";
-  return kind === "read" || kind === "export" ? "team-read" : "team-manage";
-}
-const CAPACITY_OPERATOR_CAPABILITIES = [
-  capability("operator.capabilities", "capabilities", "read", [], { uiAvailable: false, agentVisibility: "operator" }),
-  capability("discussions.read", "discussion-read", "read", ["get.v1.discussions"], { access: "project-read", uiAvailable: false }),
-  capability("discussions.send", "discussion-send", "mutation", ["post.v1.discussions"], { access: "project-read", idempotent: true, uiAvailable: false }),
-  capability("invocations.list", "agent-invocations", "read", ["get.v1.teams.teamId.agent-invocations"], { paginated: true, uiAvailable: false }),
-  capability("invocations.show", "agent-invocation", "read", ["get.v1.teams.teamId.agent-invocations.invocationId"], { uiAvailable: false }),
-  capability("invocations.cancel", "agent-invocation-cancel", "mutation", ["post.v1.teams.teamId.agent-invocations.invocationId.cancel"], { idempotent: true, uiAvailable: false }),
-  capability("communication.status", "communication-status", "read", ["get.v1.teams.teamId.communication-status"], { uiAvailable: false }),
-  capability("operation-handoffs.list", "operation-handoffs", "read", ["get.v1.teams.teamId.operation-handoffs"], { paginated: true, uiAvailable: false }),
-  capability("client-actions.list", "client-actions", "read", ["get.v1.teams.teamId.client-actions"], { paginated: true, uiAvailable: false }),
-  capability("registration-key.show", "registration-key", "read", ["get.v1.teams.teamId.capacity-registration-key"]),
-  capability("registration-key.reveal", "registration-key-reveal", "read", ["get.v1.teams.teamId.capacity-registration-key.reveal"], { secretConfirmation: true }),
-  capability("registration-key.rotate", "registration-key-rotate", "mutation", ["post.v1.teams.teamId.capacity-registration-key.rotate"], { idempotent: true, secretConfirmation: true }),
-  capability("registration-key.enable", "registration-key-enable", "mutation", ["post.v1.teams.teamId.capacity-registration-key.enable"], { idempotent: true }),
-  capability("registration-key.disable", "registration-key-disable", "mutation", ["post.v1.teams.teamId.capacity-registration-key.disable"], { idempotent: true }),
-  capability("registration-requests.list", "provider-requests", "read", ["get.v1.teams.teamId.capacity-provider-requests"], { paginated: true }),
-  capability("registration-requests.show", "provider-request", "read", ["get.v1.teams.teamId.capacity-provider-requests.requestId"]),
-  capability("registration-requests.approve", "provider-approve", "mutation", ["post.v1.teams.teamId.capacity-provider-requests.requestId.approve"], { idempotent: true }),
-  capability("registration-requests.reject", "provider-reject", "mutation", ["post.v1.teams.teamId.capacity-provider-requests.requestId.reject"], { idempotent: true }),
-  capability("registration-requests.cancel", "provider-cancel", "mutation", ["post.v1.teams.teamId.capacity-provider-requests.requestId.cancel"], { idempotent: true }),
-  capability("memberships.list", "provider-memberships", "read", ["get.v1.teams.teamId.capacity-provider-memberships"], { paginated: true }),
-  capability("memberships.show", "provider-membership", "read", ["get.v1.teams.teamId.capacity-provider-memberships.membershipId"]),
-  ...["suspend", "resume", "revoke"].map((action) => capability(`memberships.${action}`, `provider-${action}`, "mutation", [`post.v1.teams.teamId.capacity-provider-memberships.membershipId.${action}`], { idempotent: true })),
-  capability("credentials.list", "provider-credentials", "read", ["get.v1.teams.teamId.capacity-provider-memberships.membershipId.credentials"], { paginated: true }),
-  capability("credentials.rotate", "provider-team-credential-rotate", "mutation", ["post.v1.teams.teamId.capacity-provider-memberships.membershipId.credentials.rotate"], { idempotent: true }),
-  capability("credentials.revoke", "provider-credential-revoke", "mutation", ["post.v1.teams.teamId.capacity-provider-memberships.membershipId.credentials.credentialId.revoke"], { idempotent: true }),
-  capability("grants.list", "grants", "read", ["get.v1.teams.teamId.capacity-grants"], { paginated: true, configuration: "capacity-grant" }),
-  capability("grants.show", "grant", "read", ["get.v1.teams.teamId.capacity-grants.grantId"]),
-  capability("grants.validate", "grant-validate", "validate", ["post.v1.teams.teamId.capacity-grants.plan"], { configuration: "capacity-grant" }),
-  capability("grants.plan", "grant-plan", "plan", ["post.v1.teams.teamId.capacity-grants.plan"], { configuration: "capacity-grant" }),
-  capability("grants.apply", "grant-apply", "mutation", ["post.v1.teams.teamId.capacity-grants"], { idempotent: true, configuration: "capacity-grant" }),
-  ...["activate", "pause", "resume", "revoke"].map((action) => capability(`grants.${action}`, `grant-${action}`, "mutation", [`post.v1.teams.teamId.capacity-grants.grantId.${action}`], { idempotent: true })),
-  capability("allocations.list", "allocation-sets", "read", ["get.v1.teams.teamId.capacity.allocation-sets"], { paginated: true, configuration: "allocation-set" }),
-  capability("allocations.show", "allocation", "read", ["get.v1.teams.teamId.capacity.allocation-sets.allocationSetId"]),
-  capability("allocations.validate", "allocation-validate", "validate", ["post.v1.teams.teamId.capacity.allocation-sets.plan"], { configuration: "allocation-set" }),
-  capability("allocations.plan", "allocation-plan", "plan", ["post.v1.teams.teamId.capacity.allocation-sets.plan"], { configuration: "allocation-set" }),
-  capability("allocations.create", "allocation-create", "mutation", ["post.v1.teams.teamId.capacity.allocation-sets"], { idempotent: true, configuration: "allocation-set" }),
-  capability("allocations.activate", "allocation-activate", "mutation", ["post.v1.teams.teamId.capacity.allocation-sets.allocationSetId.activate"], { idempotent: true }),
-  capability("allocations.supersede", "allocation-supersede", "mutation", ["post.v1.teams.teamId.capacity.allocation-sets.allocationSetId.supersede"], { idempotent: true }),
-  capability("allocations.archive", "allocation-archive", "mutation", ["post.v1.teams.teamId.capacity.allocation-sets.allocationSetId.archive"], { idempotent: true }),
-  capability("allocations.explain", "allocation-explain", "read", ["post.v1.teams.teamId.capacity.allocation-sets.allocationSetId.explain"]),
-  capability("agent-classes.list", "agent-classes", "read", ["get.v1.projects.projectId.agent-classes"], { paginated: true, configuration: "project-agent-class" }),
-  capability("agent-classes.show", "agent-class", "read", ["get.v1.projects.projectId.agent-classes.classId"]),
-  capability("agent-classes.sync", "agent-classes-sync", "mutation", ["post.v1.projects.projectId.agent-classes", "patch.v1.projects.projectId.agent-classes.classId"], { idempotent: true, configuration: "project-agent-class", configurationInputs: ["project-agent-class", "activity-profile"] }),
-  capability("agents.author", "agent-author", "mutation", ["post.v1.teams.teamId.agent-lab.surfaces.build.authoring"], { idempotent: true }),
-  capability("agents.definitions-author", "agent-definitions-author", "mutation", ["post.v1.teams.teamId.agent-lab.surfaces.build.authoring-bundle"], { idempotent: true }),
-  capability("context-queries.test", "context-query-test", "mutation", ["post.v1.teams.teamId.projects.projectId.context-query-checks"], { access: "project-read", idempotent: true, uiAvailable: false }),
-  capability("context-queries.readiness", "context-query-checks", "read", ["get.v1.teams.teamId.projects.projectId.context-query-checks"], { access: "project-read", uiAvailable: false }),
-  capability("agents.simulate", "agent-simulation-run", "mutation", ["post.v1.teams.teamId.agent-lab.simulations"], { idempotent: true }),
-  capability("agents.deploy", "agent-deploy", "mutation", ["post.v1.teams.teamId.agent-deployments.plan", "post.v1.teams.teamId.agent-deployments.execute"], { idempotent: true, uiAvailable: false }),
-  capability("agents.deployment", "agent-deployment", "read", ["get.v1.teams.teamId.agent-deployments.deploymentId"], { uiAvailable: false }),
-  capability("agents.deployment-activate", "agent-deployment-activate", "mutation", ["post.v1.teams.teamId.agent-deployments.deploymentId.activate"], { idempotent: true, uiAvailable: false }),
-  capability("agents.deployment-upgrade", "agent-deployment-upgrade", "mutation", ["post.v1.teams.teamId.agent-deployments.deploymentId.upgrade"], { idempotent: true, uiAvailable: false }),
-  capability("capacity-plans.list", "capacity-plans", "read", ["get.v1.decisions.decisionId.capacity-plans"], { paginated: true }),
-  capability("capacity-plans.show", "capacity-plan", "read", ["get.v1.capacity-plans.capacityPlanId"]),
-  capability("capacity-plans.create", "capacity-plan-create", "mutation", ["post.v1.decisions.decisionId.capacity-plans"], { idempotent: true, uiAvailable: false }),
-  capability("capacity-plans.accept", "capacity-plan-accept", "mutation", ["post.v1.capacity-plans.capacityPlanId.accept"], { idempotent: true, uiAvailable: false }),
-  capability("capacity-plans.request-revision", "capacity-plan-request-revision", "mutation", ["post.v1.capacity-plans.capacityPlanId.request-revision"], { idempotent: true, uiAvailable: false }),
-  capability("capacity-plans.schedule", "capacity-plan-schedule", "mutation", ["post.v1.capacity-plans.capacityPlanId.schedule"], { idempotent: true, uiAvailable: false }),
-  capability("capacity-plans.supersede", "capacity-plan-supersede", "mutation", ["post.v1.capacity-plans.capacityPlanId.supersede"], { idempotent: true, uiAvailable: false }),
-  capability("workdays.create", "workday-create", "mutation", ["post.v1.workdays"], { idempotent: true }),
-  ...["start", "pause", "resume", "complete", "cancel"].map((action) => capability(`workdays.${action}`, `workday-${action}`, "mutation", [`post.v1.workdays.workdayId.${action}`], { idempotent: true })),
-  capability("workdays.tick", "workday-tick", "mutation", ["post.v1.teams.teamId.workday-runs.runId.tick"], { idempotent: true }),
-  capability("workdays.status", "workday-status", "read", ["get.v1.workdays.workdayId"]),
-  capability("workdays.summary", "workday-summary", "read", ["get.v1.workdays.workdayId.summary"], { paginated: true }),
-  capability("workdays.watch", "workday-watch", "read", ["get.v1.workdays.workdayId.summary"], { uiAvailable: false }),
-  capability("workday-runs.list", "workday-runs", "read", ["get.v1.teams.teamId.workday-runs"], { paginated: true }),
-  capability("workday-runs.show", "workday", "read", ["get.v1.teams.teamId.workday-runs.runId"]),
-  capability("workday-runs.preflight", "workday-run", "plan", ["post.v1.teams.teamId.workday-runs.preflight"]),
-  capability("workday-runs.create", "workday-run", "mutation", ["post.v1.teams.teamId.workday-runs"], { idempotent: true }),
-  capability("workday-runs.cancel", "workday-run-cancel", "mutation", ["patch.v1.teams.teamId.workday-runs.runId"], { idempotent: true }),
-  capability("workday-runs.complete", "workday-run-complete", "mutation", ["patch.v1.teams.teamId.workday-runs.runId"], { idempotent: true }),
-  capability("workday-runs.close-admission", "workday-close-admission", "mutation", ["post.v1.teams.teamId.workday-runs.runId.close-admission"], { idempotent: true, uiAvailable: false }),
-  capability("workday-schedules.list", "workday-schedules", "read", ["get.v1.teams.teamId.workday-schedules"], { paginated: true, uiAvailable: false }),
-  capability("workday-schedules.show", "workday-schedule", "read", ["get.v1.teams.teamId.workday-schedules.scheduleId"], { uiAvailable: false }),
-  capability("workday-schedules.create", "workday-schedule-create", "mutation", ["post.v1.teams.teamId.workday-schedules"], { idempotent: true, uiAvailable: false }),
-  capability("workday-schedules.update", "workday-schedule-update", "mutation", ["patch.v1.teams.teamId.workday-schedules.scheduleId"], { idempotent: true, uiAvailable: false }),
-  capability("workday-schedules.tick", "workday-schedule-tick", "mutation", ["post.v1.teams.teamId.workday-schedules.scheduleId.tick"], { idempotent: true, uiAvailable: false }),
-  capability("assignments.list", "assignments", "read", ["get.v1.teams.teamId.capacity.assignments"], { paginated: true }),
-  capability("assignments.show", "assignment", "read", ["get.v1.teams.teamId.capacity.assignments.assignmentId"]),
-  capability("assignments.authority-probe", "assignment-authority-probe", "read", ["get.v1.teams.teamId.capacity.assignments.assignmentId.authority-probe"], { uiAvailable: false }),
-  capability("assignments.explain", "assignment-explanation", "read", ["get.v1.teams.teamId.capacity.assignments.assignmentId.explanation"]),
-  capability("assignments.mode-runs", "mode-runs", "read", ["get.v1.projects.projectId.agent-mode-runs"], { paginated: true, uiAvailable: false }),
-  capability("assignments.execution-runs", "execution-runs", "read", ["get.v1.teams.teamId.capacity.execution-runs"], { paginated: true, uiAvailable: false }),
-  capability("assignments.treedx-audit", "treedx-proxy-audit", "read", ["get.v1.projects.projectId.treedx-proxy-audit"], { paginated: true, uiAvailable: false }),
-  capability("assignments.artifacts", "assignment-artifacts", "read", ["get.v1.teams.teamId.capacity.assignments.assignmentId"], { uiAvailable: false }),
-  capability("assignments.artifacts-verify", "assignment-artifacts-verify", "read", ["get.v1.teams.teamId.capacity.assignments.assignmentId"], { uiAvailable: false }),
-  capability("assignments.cancel", "assignment-cancel", "mutation", ["post.v1.teams.teamId.capacity.assignments.assignmentId.cancel"], { idempotent: true, uiAvailable: false }),
-  capability("assignments.requeue", "assignment-requeue", "mutation", ["post.v1.teams.teamId.capacity.assignments.assignmentId.requeue"], { idempotent: true, uiAvailable: false }),
-  capability("assignments.content-abandon", "content-abandon", "mutation", ["post.v1.teams.teamId.capacity.assignments.assignmentId.content-abandonment"], { idempotent: true, uiAvailable: false }),
-  capability("assignments.content-integrate", "content-integrate", "mutation", ["post.v1.teams.teamId.capacity.assignments.assignmentId.content-integration"], { idempotent: true, uiAvailable: false }),
-  capability("assignments.checkpoint-integrate", "checkpoint-integrate", "mutation", [], { idempotent: true, uiAvailable: false }),
-  capability("reservations.list", "reservations", "read", ["get.v1.teams.teamId.capacity.reservations"], { paginated: true }),
-  capability("reservations.explain", "reservation-explanation", "read", ["get.v1.teams.teamId.capacity.reservations.reservationId.explanation"]),
-  capability("usage.show", "usage", "read", ["get.v1.teams.teamId.capacity.usage"], { paginated: true }),
-  capability("usage.export", "usage-export", "export", ["get.v1.teams.teamId.capacity.usage"], { paginated: true }),
-  capability("ledger.show", "ledger", "read", ["get.v1.teams.teamId.capacity.ledger"], { paginated: true }),
-  capability("ledger.export", "ledger-export", "export", ["get.v1.teams.teamId.capacity.ledger"], { paginated: true }),
-  capability("audit.list", "audit-events", "read", ["get.v1.teams.teamId.capacity-audit-events"], { paginated: true }),
-  capability("audit.export", "audit-export", "export", ["get.v1.teams.teamId.capacity-audit-events"], { paginated: true }),
-  capability("provider.identity.init", "provider-identity-init", "mutation", [], { configuration: "provider-manifest" }),
-  capability("provider.identity.show", "provider-identity-show", "read"),
-  capability("provider.identity.rotate", "provider-identity-rotate", "mutation", ["post.v1.provider.identity.rotate"], { idempotent: true }),
-  capability("provider.manifest.init", "provider-manifest-init", "mutation", [], { configuration: "provider-manifest" }),
-  capability("provider.join", "provider-join", "mutation", ["post.v1.provider-registrations"], { idempotent: true, configuration: "provider-offer" }),
-  capability("provider.registration-status", "provider-registration-status", "read", ["get.v1.provider-registrations.requestId"]),
-  capability("provider.credential-exchange", "provider-credential-exchange", "mutation", ["post.v1.provider-registrations.requestId.credential"], { idempotent: true }),
-  capability("provider.credential-rotate", "provider-credential-rotate", "mutation", ["post.v1.provider.credential-rotation"], { idempotent: true }),
-  capability("provider.connections.list", "provider-connections", "read", [], { configuration: "provider-manifest" }),
-  capability("provider.connections.show", "provider-connection", "read"),
-  capability("provider.connections.leave", "provider-leave", "mutation", ["post.v1.provider.membership.leave"], { idempotent: true }),
-  capability("provider.offer.validate", "provider-offer-validate", "validate", [], { configuration: "provider-offer" }),
-  capability("provider.offer.plan", "provider-offer-plan", "plan", [], { configuration: "provider-offer" }),
-  capability("provider.offer.apply", "provider-offer-apply", "mutation", ["post.v1.provider.availability-sessions"], { configuration: "provider-offer" }),
-  ...["build", "up", "status", "logs", "down", "test-local"].map((action) => capability(`provider.runtime.${action}`, action, "local-runtime"))
-];
-function validateCapacityOperatorCapabilityMatrix() {
-  const diagnostics = [];
-  const ids = /* @__PURE__ */ new Set();
-  const actions = /* @__PURE__ */ new Set();
-  for (const capability2 of CAPACITY_OPERATOR_CAPABILITIES) {
-    if (ids.has(capability2.id)) diagnostics.push(`Duplicate capability id: ${capability2.id}`);
-    if (actions.has(capability2.cliAction) && capability2.cliAction !== "workday-run") diagnostics.push(`Duplicate CLI action owner: ${capability2.cliAction}`);
-    ids.add(capability2.id);
-    actions.add(capability2.cliAction);
-    if (capability2.kind === "mutation" && capability2.apiRouteIds.length > 0 && capability2.idempotent !== true && !capability2.id.startsWith("provider.offer")) {
-      diagnostics.push(`API mutation is not declared idempotent: ${capability2.id}`);
-    }
-  }
-  return { ok: diagnostics.length === 0, diagnostics };
-}
-function renderCapacityOperatorCapabilityMarkdown() {
-  const lines = [
-    "# Agent Capacity Operator Parity",
-    "",
-    "> Generated from `CAPACITY_OPERATOR_CAPABILITIES`. Do not hand-edit this file.",
-    "",
-    "| Capability | CLI action | API route descriptors | Kind | Access | Mutation | Confirmation | UI | Agent | Pagination | Configuration |",
-    "| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |"
-  ];
-  for (const capability2 of CAPACITY_OPERATOR_CAPABILITIES) {
-    lines.push(`| \`${capability2.id}\` | \`trsd capacity ${capability2.cliAction}\` | ${capability2.apiRouteIds.map((route) => `\`${route}\``).join("<br>") || "local"} | ${capability2.kind} | ${capability2.access} | ${capability2.mutationMode} | ${capability2.confirmation} | ${capability2.uiAvailable ? "yes" : "no"} | ${capability2.agentVisibility} | ${capability2.paginated ? "bounded cursor" : "\u2014"} | ${(capability2.configurationInputs ?? (capability2.configuration ? [capability2.configuration] : [])).join("<br>") || "\u2014"} |`);
-  }
-  lines.push("", "## Declarative configuration inventory", "", "| Family | Schema | Validator | Format | Runtime owner | Example |", "| --- | --- | --- | --- | --- | --- |");
-  for (const descriptor of CAPACITY_CONFIGURATION_DESCRIPTORS) {
-    lines.push(`| \`${descriptor.id}\` | \`${descriptor.schemaId}\` | \`${descriptor.validator}\` | ${descriptor.format} | \`${descriptor.runtimeOwner}\` | \`${descriptor.examplePath}\` |`);
-  }
-  return `${lines.join("\n")}
-`;
-}
-export {
-  CAPACITY_OPERATOR_CAPABILITIES,
-  renderCapacityOperatorCapabilityMarkdown,
-  validateCapacityOperatorCapabilityMatrix
-};

package/dist/agent-capacity/cooperative-planning.d.ts

@@ -1,28 +0,0 @@
-import type { AgentPlanningGraph } from './planning-graph.js';
-export declare const COOPERATIVE_PLANNING_STAGES: readonly ["discovery", "synthesis", "deliberation", "evaluation", "revision", "closeout"];
-export type CooperativePlanningStage = typeof COOPERATIVE_PLANNING_STAGES[number];
-export interface PlanningParticipant {
-    agentId: string;
-    nodeId: string;
-    projectAgentClassId: string;
-    timeboxSeconds: number;
-}
-export interface PlanningWave {
-    round: number;
-    wave: number;
-    stage: CooperativePlanningStage;
-    participantNodeIds: string[];
-    requestedSeconds: number;
-}
-export declare function expandSignalDependencyClosure(graph: AgentPlanningGraph, targetNodeIds: string[]): string[];
-export declare function compileCooperativePlanningWaves(input: {
-    graph: AgentPlanningGraph;
-    participants: PlanningParticipant[];
-    rounds: number;
-    maxConcurrentAssignments: number;
-    allocatedSeconds: number;
-}): {
-    waves: PlanningWave[];
-    requiredSeconds: number;
-    fits: boolean;
-};

package/dist/agent-capacity/cooperative-planning.js

@@ -1,48 +0,0 @@
-const COOPERATIVE_PLANNING_STAGES = ["discovery", "synthesis", "deliberation", "evaluation", "revision", "closeout"];
-function expandSignalDependencyClosure(graph, targetNodeIds) {
-  const selected = new Set(targetNodeIds);
-  const queue = [...targetNodeIds];
-  while (queue.length) {
-    const target = queue.shift();
-    for (const edge of graph.edges.filter((entry) => entry.toNodeId === target)) {
-      if (selected.has(edge.fromNodeId)) continue;
-      selected.add(edge.fromNodeId);
-      queue.push(edge.fromNodeId);
-    }
-  }
-  return [...selected].sort();
-}
-function stageFor(nodeStage) {
-  if (COOPERATIVE_PLANNING_STAGES.includes(nodeStage)) return nodeStage;
-  return "deliberation";
-}
-function compileCooperativePlanningWaves(input) {
-  const concurrency = Math.max(1, Math.floor(input.maxConcurrentAssignments));
-  const rounds = Math.max(1, Math.floor(input.rounds));
-  const byNode = new Map(input.participants.map((entry) => [entry.nodeId, entry]));
-  const waves = [];
-  let requiredSeconds = 0;
-  const roundFor = (stage) => stage === "discovery" || stage === "synthesis" ? 1 : stage === "deliberation" || stage === "evaluation" ? Math.min(2, rounds) : stage === "revision" ? rounds : rounds + 1;
-  for (let round = 1; round <= rounds + 1; round += 1) {
-    const ordered = input.graph.nodes.filter((entry) => byNode.has(entry.id) && roundFor(stageFor(entry.stage)) === round).sort((left, right) => {
-      const stage = COOPERATIVE_PLANNING_STAGES.indexOf(stageFor(left.stage)) - COOPERATIVE_PLANNING_STAGES.indexOf(stageFor(right.stage));
-      return stage || left.id.localeCompare(right.id);
-    });
-    let waveIndex = 0;
-    for (const stage of COOPERATIVE_PLANNING_STAGES) {
-      const stageNodes = ordered.filter((entry) => stageFor(entry.stage) === stage);
-      for (let cursor = 0; cursor < stageNodes.length; cursor += concurrency) {
-        const cohort = stageNodes.slice(cursor, cursor + concurrency);
-        const requestedSeconds = cohort.reduce((sum, entry) => sum + (byNode.get(entry.id)?.timeboxSeconds ?? 0), 0);
-        requiredSeconds += requestedSeconds;
-        waves.push({ round, wave: ++waveIndex, stage, participantNodeIds: cohort.map((entry) => entry.id), requestedSeconds });
-      }
-    }
-  }
-  return { waves, requiredSeconds, fits: requiredSeconds <= input.allocatedSeconds };
-}
-export {
-  COOPERATIVE_PLANNING_STAGES,
-  compileCooperativePlanningWaves,
-  expandSignalDependencyClosure
-};

package/dist/agent-capacity/index.d.ts

@@ -1,15 +0,0 @@
-export * from './allocation.js';
-export * from './artifacts.js';
-export * from './authority/agent-authority-presets.js';
-export * from './authority/assignment-authority-probe.js';
-export * from './artifact-mutation-receipt.js';
-export * from './authoring/index.js';
-export * from './cooperative-planning.js';
-export * from './planning-graph.js';
-export * from './contracts/index.js';
-export * from './policy/index.js';
-export * from './validation/index.js';
-export * from './workday.js';
-export * from '../governance/groups/contracts.js';
-export * from '../governance/groups/membership.js';
-export * from '../governance/groups/signal-scope.js';

package/dist/agent-capacity/index.js

@@ -1,15 +0,0 @@
-export * from "./allocation.js";
-export * from "./artifacts.js";
-export * from "./authority/agent-authority-presets.js";
-export * from "./authority/assignment-authority-probe.js";
-export * from "./artifact-mutation-receipt.js";
-export * from "./authoring/index.js";
-export * from "./cooperative-planning.js";
-export * from "./planning-graph.js";
-export * from "./contracts/index.js";
-export * from "./policy/index.js";
-export * from "./validation/index.js";
-export * from "./workday.js";
-export * from "../governance/groups/contracts.js";
-export * from "../governance/groups/membership.js";
-export * from "../governance/groups/signal-scope.js";

package/dist/agent-capacity/planning-graph.d.ts

@@ -1,77 +0,0 @@
-import type { EffectiveGroupMembership, SignalGroupScope } from '../governance/groups/contracts.js';
-import type { AgentSignalContract } from './validation/agent-signal.js';
-export type SignalProducerPolicy = 'any' | 'all' | 'quorum';
-export interface SignalSubscription {
-    contract: string;
-    groupScope?: SignalGroupScope;
-    filters?: Record<string, unknown>;
-    cardinality?: 'single' | 'each';
-    producerPolicy?: SignalProducerPolicy;
-    quorum?: number;
-}
-export interface PlanningGraphProfile {
-    id?: string;
-    agentId: string;
-    activityType: string;
-    stage?: string | null;
-    signals?: {
-        subscribesTo?: SignalSubscription[];
-        publishes?: string[];
-    };
-}
-export interface PlanningGraphNode {
-    id: string;
-    agentId: string;
-    activityType: string;
-    stage: string | null;
-    requires: SignalSubscription[];
-    produces: string[];
-}
-export interface PlanningGraphEdge {
-    fromNodeId: string;
-    toNodeId: string;
-    contracts: string[];
-}
-export interface PlanningGraphDiagnostic {
-    code: 'duplicate_node' | 'missing_producer' | 'self_dependency' | 'cycle' | 'invalid_quorum' | 'missing_contract' | 'publisher_not_allowed' | 'subscriber_not_allowed' | 'filter_not_allowed';
-    nodeId: string;
-    contractId?: string;
-    message: string;
-}
-export interface AgentPlanningGraph {
-    nodes: PlanningGraphNode[];
-    edges: PlanningGraphEdge[];
-    externalRoots: string[];
-    diagnostics: PlanningGraphDiagnostic[];
-    ok: boolean;
-}
-export interface PlanningGraphEvidenceReference {
-    contractId: string;
-    recordId: string;
-    subjectId?: string | null;
-    payload?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-    groupMembership?: EffectiveGroupMembership;
-}
-export interface PlanningGraphGroupContext {
-    projectId: string;
-    agentMembershipByNodeId: Record<string, EffectiveGroupMembership>;
-    depthByGroupId?: Record<string, number>;
-}
-export interface PlanningGraphNodeEvidence {
-    nodeId: string;
-    references: PlanningGraphEvidenceReference[];
-}
-export declare function compileAgentPlanningGraph(profiles: PlanningGraphProfile[], options?: {
-    externalRoots?: string[];
-    contracts?: Record<string, AgentSignalContract>;
-}): AgentPlanningGraph;
-export declare function evaluatePlanningGraphNode(graph: AgentPlanningGraph, nodeId: string, evidence: PlanningGraphNodeEvidence[], groups?: PlanningGraphGroupContext): {
-    ready: boolean;
-    missing: SignalSubscription[];
-    matched: PlanningGraphNodeEvidence[];
-};
-export declare function evaluatePlanningGraphNodeInstances(graph: AgentPlanningGraph, nodeId: string, evidence: PlanningGraphNodeEvidence[], groups?: PlanningGraphGroupContext): {
-    instanceKey: string;
-    matched: PlanningGraphNodeEvidence[];
-}[];

package/dist/agent-capacity/planning-graph.js

@@ -1,155 +0,0 @@
-import { matchSignalGroupScope } from "../governance/groups/signal-scope.js";
-function normalize(value) {
-  return value.trim().replace(/_/gu, "-");
-}
-function unique(values = []) {
-  return [...new Set(values.map(normalize).filter(Boolean))].sort();
-}
-function node(profile) {
-  return {
-    id: profile.id?.trim() || `${profile.agentId}:${profile.activityType}`,
-    agentId: profile.agentId,
-    activityType: profile.activityType,
-    stage: profile.stage?.trim() || null,
-    requires: (profile.signals?.subscribesTo ?? []).map((entry) => ({
-      ...entry,
-      contract: normalize(entry.contract),
-      cardinality: entry.cardinality ?? "single",
-      producerPolicy: entry.producerPolicy ?? "any"
-    })).sort((left, right) => left.contract.localeCompare(right.contract)),
-    produces: unique(profile.signals?.publishes)
-  };
-}
-function cycles(nodes, edges) {
-  const outgoing = new Map(nodes.map((entry) => [entry.id, []]));
-  const incoming = new Map(nodes.map((entry) => [entry.id, 0]));
-  for (const edge of edges) {
-    outgoing.get(edge.fromNodeId)?.push(edge.toNodeId);
-    incoming.set(edge.toNodeId, (incoming.get(edge.toNodeId) ?? 0) + 1);
-  }
-  const ready = nodes.filter((entry) => incoming.get(entry.id) === 0).map((entry) => entry.id).sort();
-  let visited = 0;
-  while (ready.length) {
-    const id = ready.shift();
-    visited += 1;
-    for (const target of outgoing.get(id) ?? []) {
-      const count = (incoming.get(target) ?? 0) - 1;
-      incoming.set(target, count);
-      if (!count) ready.push(target);
-    }
-    ready.sort();
-  }
-  return visited === nodes.length ? [] : nodes.filter((entry) => (incoming.get(entry.id) ?? 0) > 0).map((entry) => ({
-    code: "cycle",
-    nodeId: entry.id,
-    message: `Signal graph node ${entry.id} participates in a cycle.`
-  }));
-}
-function compileAgentPlanningGraph(profiles, options = {}) {
-  const nodes = profiles.map(node).sort((left, right) => left.id.localeCompare(right.id));
-  const externalRoots = unique(options.externalRoots);
-  const diagnostics = [];
-  const byId = /* @__PURE__ */ new Map();
-  for (const entry of nodes) {
-    if (byId.has(entry.id)) diagnostics.push({ code: "duplicate_node", nodeId: entry.id, message: `Signal graph node ${entry.id} is declared more than once.` });
-    else byId.set(entry.id, entry);
-  }
-  const producers = /* @__PURE__ */ new Map();
-  for (const entry of byId.values()) for (const contract of entry.produces) {
-    const definition = options.contracts?.[contract];
-    if (options.contracts && !definition) diagnostics.push({ code: "missing_contract", nodeId: entry.id, contractId: contract, message: `${entry.id} publishes unknown signal contract ${contract}.` });
-    else if (definition?.allowedProducerProfiles?.length && !definition.allowedProducerProfiles.includes(entry.activityType)) diagnostics.push({ code: "publisher_not_allowed", nodeId: entry.id, contractId: contract, message: `${entry.activityType} may not publish ${contract}.` });
-    producers.set(contract, [...producers.get(contract) ?? [], entry]);
-  }
-  const grouped = /* @__PURE__ */ new Map();
-  for (const entry of byId.values()) for (const subscription of entry.requires) {
-    const definition = options.contracts?.[subscription.contract];
-    if (options.contracts && !definition) diagnostics.push({ code: "missing_contract", nodeId: entry.id, contractId: subscription.contract, message: `${entry.id} subscribes to unknown signal contract ${subscription.contract}.` });
-    if (definition?.subscriberActivityProfiles?.length && !definition.subscriberActivityProfiles.includes(entry.activityType)) diagnostics.push({ code: "subscriber_not_allowed", nodeId: entry.id, contractId: subscription.contract, message: `${entry.activityType} may not subscribe to ${subscription.contract}.` });
-    const invalidFilters = Object.keys(subscription.filters ?? {}).filter((key) => !definition?.filterableFields?.includes(key));
-    if (definition && invalidFilters.length) diagnostics.push({ code: "filter_not_allowed", nodeId: entry.id, contractId: subscription.contract, message: `${subscription.contract} does not expose filter fields: ${invalidFilters.join(", ")}.` });
-    const candidates = (producers.get(subscription.contract) ?? []).filter((producer) => producer.id !== entry.id);
-    const self = (producers.get(subscription.contract) ?? []).some((producer) => producer.id === entry.id);
-    if (!candidates.length && !externalRoots.includes(subscription.contract)) diagnostics.push({
-      code: self ? "self_dependency" : "missing_producer",
-      nodeId: entry.id,
-      contractId: subscription.contract,
-      message: `${entry.id} subscribes to ${subscription.contract}, but ${self ? "only publishes it itself" : "no selected profile or external root publishes it"}.`
-    });
-    if (subscription.producerPolicy === "quorum" && (subscription.quorum ?? 0) > candidates.length) diagnostics.push({
-      code: "invalid_quorum",
-      nodeId: entry.id,
-      contractId: subscription.contract,
-      message: `${entry.id} requires quorum ${subscription.quorum}, but only ${candidates.length} producers exist.`
-    });
-    for (const producer of candidates) {
-      const key = `${producer.id}\0${entry.id}`;
-      grouped.set(key, [...grouped.get(key) ?? [], subscription.contract]);
-    }
-  }
-  const edges = [...grouped].map(([key, contracts]) => {
-    const [fromNodeId, toNodeId] = key.split("\0");
-    return { fromNodeId, toNodeId, contracts: unique(contracts) };
-  }).sort((left, right) => `${left.fromNodeId}:${left.toNodeId}`.localeCompare(`${right.fromNodeId}:${right.toNodeId}`));
-  diagnostics.push(...cycles([...byId.values()], edges));
-  return { nodes: [...byId.values()], edges, externalRoots, diagnostics, ok: diagnostics.length === 0 };
-}
-function matchesFilters(reference, filters = {}) {
-  const values = { ...reference.payload ?? {}, ...reference.metadata ?? {} };
-  return Object.entries(filters).every(([key, expected]) => {
-    const actual = values[key];
-    return Array.isArray(expected) ? expected.includes(actual) || Array.isArray(actual) && actual.some((item) => expected.includes(item)) : actual === expected;
-  });
-}
-function satisfying(graph, node2, subscription, evidence, groups) {
-  const predecessorIds = new Set(graph.edges.filter((edge) => edge.toNodeId === node2.id && edge.contracts.includes(subscription.contract)).map((edge) => edge.fromNodeId));
-  return evidence.flatMap((entry) => entry.references.filter(
-    (reference) => (entry.nodeId === "$external" || predecessorIds.has(entry.nodeId)) && normalize(reference.contractId) === subscription.contract && matchesFilters(reference, subscription.filters) && matchesGroups(node2, subscription, reference, groups)
-  ).map((reference) => ({ nodeId: entry.nodeId, reference })));
-}
-function matchesGroups(node2, subscription, reference, groups) {
-  if (!subscription.groupScope) return true;
-  if (!groups) return false;
-  const agentMembership = groups.agentMembershipByNodeId[node2.id];
-  const subjectMembership = reference.groupMembership;
-  if (!agentMembership || !subjectMembership) return false;
-  return matchSignalGroupScope({ scope: subscription.groupScope, agentMembership, subjectMembership, depthByGroupId: groups.depthByGroupId }).matched;
-}
-function evaluatePlanningGraphNode(graph, nodeId, evidence, groups) {
-  const selected = graph.nodes.find((entry) => entry.id === nodeId);
-  if (!selected || !graph.ok) return { ready: false, missing: selected?.requires ?? [], matched: [] };
-  const matched = /* @__PURE__ */ new Map();
-  const missing = selected.requires.filter((subscription) => {
-    const found = satisfying(graph, selected, subscription, evidence, groups);
-    for (const item of found) matched.set(item.nodeId, [...matched.get(item.nodeId) ?? [], item.reference]);
-    const producerCount = new Set(found.map((item) => item.nodeId)).size;
-    if (subscription.producerPolicy === "all") {
-      const expected = new Set(graph.edges.filter((edge) => edge.toNodeId === nodeId && edge.contracts.includes(subscription.contract)).map((edge) => edge.fromNodeId)).size;
-      return producerCount < expected;
-    }
-    if (subscription.producerPolicy === "quorum") return producerCount < (subscription.quorum ?? 1);
-    return found.length === 0;
-  });
-  return { ready: missing.length === 0, missing, matched: [...matched].map(([entryNodeId, references]) => ({ nodeId: entryNodeId, references })) };
-}
-function evaluatePlanningGraphNodeInstances(graph, nodeId, evidence, groups) {
-  const selected = graph.nodes.find((entry) => entry.id === nodeId);
-  if (!selected) return [];
-  const each = selected.requires.find((entry) => entry.cardinality === "each");
-  if (!each) {
-    const result = evaluatePlanningGraphNode(graph, nodeId, evidence, groups);
-    return result.ready ? [{ instanceKey: "single", matched: result.matched }] : [];
-  }
-  const anchors = satisfying(graph, selected, each, evidence, groups);
-  return anchors.flatMap(({ reference }) => {
-    const subject = reference.subjectId ?? reference.recordId;
-    const scoped = evidence.map((entry) => ({ ...entry, references: entry.references.filter((candidate) => (candidate.subjectId ?? candidate.recordId) === subject) }));
-    const result = evaluatePlanningGraphNode(graph, nodeId, scoped, groups);
-    return result.ready ? [{ instanceKey: subject, matched: result.matched }] : [];
-  }).filter((entry, index, all) => all.findIndex((candidate) => candidate.instanceKey === entry.instanceKey) === index).sort((left, right) => left.instanceKey.localeCompare(right.instanceKey));
-}
-export {
-  compileAgentPlanningGraph,
-  evaluatePlanningGraphNode,
-  evaluatePlanningGraphNodeInstances
-};

package/dist/agent-capacity/policy/capacity/accounting/settlement.d.ts

@@ -1,8 +0,0 @@
-import { type ProviderAssignment } from '../../../contracts/capacity/assignments/assignment-records.js';
-import type { CapacitySettlementInvariantResult } from '../../../contracts/runtime/runtime-observability.js';
-import type { CapacityLedgerEntry, CapacityReservation } from '../../../contracts/support/financial-records.js';
-export declare function validateCapacitySettlementInvariant(input: {
-    assignment: ProviderAssignment;
-    reservation?: CapacityReservation | null;
-    ledgerEntries: CapacityLedgerEntry[];
-}): CapacitySettlementInvariantResult;

package/dist/agent-capacity/policy/capacity/accounting/settlement.js

@@ -1,50 +0,0 @@
-import { hasAcceptedCapacityPlanProvenance } from "../../support/planning.js";
-function validateCapacitySettlementInvariant(input) {
-  const violations = [];
-  const assignmentEntries = input.ledgerEntries.filter((entry) => !entry.assignmentId || entry.assignmentId === input.assignment.id);
-  const byPhase = /* @__PURE__ */ new Map();
-  for (const entry of assignmentEntries) {
-    byPhase.set(String(entry.phase), [...byPhase.get(String(entry.phase)) ?? [], entry]);
-    if (Number(entry.activeSeconds ?? 0) < 0 || Number(entry.elapsedSeconds ?? 0) < 0) {
-      violations.push({ code: "negative_settled_time", message: `Ledger entry ${entry.id} has negative time.`, severity: "error" });
-    }
-  }
-  const completion = byPhase.get("task_completed_actual_settlement") ?? [];
-  if (completion.length > 1) {
-    violations.push({ code: "duplicate_completion_settlement", message: `Assignment ${input.assignment.id} has ${completion.length} completion settlement entries.`, severity: "error" });
-  }
-  const releases = byPhase.get("reservation_released") ?? [];
-  if (input.reservation && releases.length) {
-    const consumed = Math.max(...completion.map((entry) => Number(entry.activeSeconds ?? 0)), Number(input.reservation.activeSeconds ?? 0), 0);
-    const reserved = Number(input.reservation.reservedSeconds ?? 0);
-    const released = releases.reduce((sum, entry) => sum + Number(entry.activeSeconds ?? 0), 0);
-    if (released > Math.max(0, reserved - consumed) + 1e-6) {
-      violations.push({ code: "reservation_release_exceeds_unused", message: `Released ${released} seconds exceeds unused reservation ${Math.max(0, reserved - consumed)}.`, severity: "error" });
-    }
-  }
-  const refunds = byPhase.get("task_failed_refund") ?? [];
-  if (input.reservation && refunds.reduce((sum, entry) => sum + Number(entry.activeSeconds ?? 0), 0) > Number(input.reservation.reservedSeconds ?? 0) + 1e-6) {
-    violations.push({ code: "refund_exceeds_reserved", message: "Failure release exceeds reserved agent time.", severity: "error" });
-  }
-  if (input.assignment.status === "completed" && completion.length === 0 && input.assignment.reservationId) {
-    violations.push({ code: "completed_assignment_missing_settlement", message: "Completed assignment with a reservation has no completion settlement.", severity: "error" });
-  }
-  if (input.assignment.status === "completed") {
-    const hasModeRun = Boolean(input.assignment.lifecycleOutput?.modeRunId ?? input.assignment.lifecycleOutput?.usageActualId ?? completion.some((entry) => entry.modeRunId));
-    if (!hasModeRun) {
-      violations.push({ code: "completed_assignment_missing_mode_run_or_usage", message: "Completed assignment does not link a mode run or usage actual.", severity: "warning" });
-    }
-  }
-  if (input.assignment.mode === "acting" && !hasAcceptedCapacityPlanProvenance({ assignment: input.assignment })) {
-    violations.push({ code: "acting_assignment_missing_capacity_plan_provenance", message: "Acting assignment lacks accepted, scheduled, or active capacity-plan provenance.", severity: "error" });
-  }
-  const hasErrors = violations.some((violation) => violation.severity === "error");
-  return {
-    ok: violations.length === 0,
-    status: hasErrors ? "fail" : violations.length ? "warning" : "pass",
-    violations
-  };
-}
-export {
-  validateCapacitySettlementInvariant
-};

package/dist/agent-capacity/policy/capacity/assignments/assignment-capability.d.ts

@@ -1,20 +0,0 @@
-import { type AgentCapacityEnvelope, type DecisionExecutionInput, type ProviderAssignment, type ProviderAssignmentCapabilityHandles, type TreeDxProxyHandle } from '../../../contracts/capacity/assignments/assignment-records.js';
-import type { AgentKernelModeFallback, ProviderAssignmentSynthesisCandidate, TreeDxProxyAccessRequest, TreeDxProxyAccessResult } from '../../../contracts/runtime/runtime-observability.js';
-export declare function isProviderAssignmentCandidateEligible(candidate: ProviderAssignmentSynthesisCandidate): boolean;
-export declare function validateTreeDxProxyHandle(handle: TreeDxProxyHandle | null | undefined, expected: {
-    teamId?: string | null;
-    projectId: string;
-    assignmentId?: string | null;
-}): AgentKernelModeFallback | null;
-export declare function redactedProviderAssignmentCapabilityHandles(handles: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null | undefined): ProviderAssignmentCapabilityHandles;
-export declare function providerAssignmentCapabilityHandlesContainSecretMaterial(value: unknown): boolean;
-export declare function validateProviderAssignmentCapabilityHandles(input: {
-    assignment: Pick<ProviderAssignment, 'id' | 'teamId' | 'projectId' | 'mode' | 'metadata' | 'decisionInput' | 'capacityEnvelope' | 'synthesizedFrom'> & {
-        capabilityHandles?: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null;
-    };
-    capabilityHandles?: ProviderAssignmentCapabilityHandles | Record<string, unknown> | null;
-    decisionInput?: DecisionExecutionInput | null;
-    capacityEnvelope?: AgentCapacityEnvelope | null;
-    now?: Date;
-}): AgentKernelModeFallback | null;
-export declare function evaluateTreeDxProxyHandleAccess(handle: TreeDxProxyHandle | Record<string, unknown> | null | undefined, request: TreeDxProxyAccessRequest): TreeDxProxyAccessResult;