@treeseed/sdk 0.12.62 → 0.13.0-rc.2

package/dist/agent-capacity/artifact-mutation-receipt.d.ts

@@ -0,0 +1,49 @@
+export declare const ARTIFACT_MUTATION_RECEIPT_SCHEMA: "treeseed.artifact-mutation-receipt/v1";
+export type ArtifactMutationKind = 'treedx-content' | 'source-checkpoint';
+export type ArtifactMutationPhase = 'provisional' | 'integrated';
+import type { AgentWorkExecutionMode, UpstreamMutationPolicy } from './contracts/support/execution-mode.js';
+export interface ArtifactMutationEvidence {
+    ref: string;
+    digest?: string | null;
+    artifactRefs: string[];
+}
+/** Portable proof that an assignment changed one governed artifact boundary. */
+export interface ArtifactMutationReceipt {
+    schemaVersion: typeof ARTIFACT_MUTATION_RECEIPT_SCHEMA;
+    id: string;
+    kind: ArtifactMutationKind;
+    phase: ArtifactMutationPhase;
+    executionMode: AgentWorkExecutionMode;
+    upstreamMutationPolicy: UpstreamMutationPolicy;
+    assignmentId: string;
+    modeRunId: string;
+    teamId: string;
+    projectId: string;
+    baseRef: string;
+    effectiveRef: string;
+    changedPaths: string[];
+    before: ArtifactMutationEvidence;
+    after: ArtifactMutationEvidence;
+    review?: {
+        reviewerId: string;
+        disposition: 'approved' | 'rejected';
+        evidenceReason: string;
+        workdayId: string;
+    };
+    integration?: {
+        actorId: string;
+        targetRef: string;
+        observedRef: string;
+        observedPaths?: string[];
+    };
+    createdAt: string;
+}
+export declare function validateArtifactMutationReceipt(value: unknown): {
+    ok: false;
+    reason: string;
+    value?: undefined;
+} | {
+    ok: true;
+    value: ArtifactMutationReceipt;
+    reason?: undefined;
+};

package/dist/agent-capacity/artifact-mutation-receipt.js

@@ -0,0 +1,36 @@
+const ARTIFACT_MUTATION_RECEIPT_SCHEMA = "treeseed.artifact-mutation-receipt/v1";
+function exactRef(value) {
+  return typeof value === "string" && value.trim().length > 0 && !/^(?:HEAD|main|master|staging|latest)$/iu.test(value.trim());
+}
+function digest(value) {
+  return value == null || typeof value === "string" && /^(?:sha256:)?[a-f0-9]{64}$/u.test(value);
+}
+function validateArtifactMutationReceipt(value) {
+  const receipt = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const problems = [];
+  if (receipt.schemaVersion !== ARTIFACT_MUTATION_RECEIPT_SCHEMA) problems.push("schemaVersion");
+  for (const key of ["id", "assignmentId", "modeRunId", "teamId", "projectId"]) if (!exactRef(receipt[key])) problems.push(key);
+  if (!["treedx-content", "source-checkpoint"].includes(String(receipt.kind))) problems.push("kind");
+  if (!["provisional", "integrated"].includes(String(receipt.phase))) problems.push("phase");
+  if (!["simulation", "production"].includes(String(receipt.executionMode))) problems.push("executionMode");
+  if (!["denied", "checkpoint-only", "exact-approved-ref"].includes(String(receipt.upstreamMutationPolicy))) problems.push("upstreamMutationPolicy");
+  if (receipt.executionMode === "simulation" && receipt.upstreamMutationPolicy !== "denied") problems.push("upstreamMutationPolicy");
+  if (receipt.phase === "provisional" && receipt.upstreamMutationPolicy === "exact-approved-ref") problems.push("upstreamMutationPolicy");
+  if (receipt.phase === "integrated" && receipt.executionMode === "production" && receipt.upstreamMutationPolicy !== "exact-approved-ref") problems.push("upstreamMutationPolicy");
+  if (!exactRef(receipt.baseRef)) problems.push("baseRef");
+  if (!exactRef(receipt.effectiveRef)) problems.push("effectiveRef");
+  if (receipt.baseRef === receipt.effectiveRef) problems.push("effectiveRef");
+  if (!Array.isArray(receipt.changedPaths) || !receipt.changedPaths.length || receipt.changedPaths.some((path) => typeof path !== "string" || !path.trim())) problems.push("changedPaths");
+  for (const key of ["before", "after"]) {
+    const evidence = receipt[key];
+    if (!evidence || !exactRef(evidence.ref) || !Array.isArray(evidence.artifactRefs) || !digest(evidence.digest)) problems.push(key);
+  }
+  if (receipt.before?.ref !== receipt.baseRef) problems.push("before.ref");
+  if (receipt.after?.ref !== receipt.effectiveRef) problems.push("after.ref");
+  if (!receipt.createdAt || Number.isNaN(Date.parse(receipt.createdAt))) problems.push("createdAt");
+  return problems.length ? { ok: false, reason: `Artifact mutation receipt has invalid fields: ${[...new Set(problems)].join(", ")}.` } : { ok: true, value: receipt };
+}
+export {
+  ARTIFACT_MUTATION_RECEIPT_SCHEMA,
+  validateArtifactMutationReceipt
+};

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

@@ -0,0 +1,107 @@
+import type { ExecutionUsageActual } from '../types/agents.js';
+import type { ResearchCitation } from './contracts/support/research-citation.js';
+import type { ArtifactRef } from '../treedx/types.js';
+import { type ArtifactMutationReceipt } from './artifact-mutation-receipt.js';
+export interface AgentToolEventReference {
+    id: string;
+    toolId: string;
+    status: 'completed' | 'failed';
+    operation?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    durationMs?: number | null;
+    derivedEventTypes: string[];
+    capturedInputRef?: string | null;
+    capturedOutputRef?: string | null;
+}
+export interface AgentContentReference {
+    model: string;
+    contentPath: string;
+    receiptId: string;
+    toolEventId: string;
+    subjectId?: string | null;
+    subjectField?: string | null;
+    artifactKind?: string | null;
+    producedByAgent?: string | null;
+    commitSha?: string | null;
+    ref?: string | null;
+    groupIds?: string[];
+}
+export interface AgentSourceWorktreeReference {
+    root?: string | null;
+    branch?: string | null;
+    baseRef?: string | null;
+    changedPaths: string[];
+}
+export interface AgentCommitReference {
+    sha: string;
+    ref?: string | null;
+    message?: string | null;
+}
+export interface AgentVerificationResult {
+    status: 'passed' | 'failed' | 'not-run' | 'unknown' | string;
+    summary?: string | null;
+    commands?: string[];
+    evidenceRefs?: string[];
+}
+export interface AgentSignal {
+    code: string;
+    severity: 'info' | 'warning' | 'error';
+    message?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentControlPlaneReference {
+    kind: string;
+    id: string;
+    status?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentDiagnosticReference {
+    code: string;
+    message?: string | null;
+    retryable?: boolean | null;
+    evidenceRef?: string | null;
+}
+/** Portable, secret-free terminal evidence emitted by AgentKernel. */
+export interface AgentArtifactManifest {
+    schemaVersion: 1;
+    assignmentId: string;
+    modeRunId: string;
+    teamId: string;
+    projectId: string;
+    workDayId?: string | null;
+    providerId: string;
+    runnerId?: string | null;
+    executionProviderId?: string | null;
+    mode: 'planning' | 'acting';
+    agentClassId: string;
+    agentId: string;
+    handlerId: string;
+    activityType: string;
+    status: 'completed' | 'returned' | 'failed';
+    summary: string;
+    toolEvents: AgentToolEventReference[];
+    contentReferences: AgentContentReference[];
+    mutationReceipts?: ArtifactMutationReceipt[];
+    artifactReferences?: ArtifactRef[];
+    sourceWorktree?: AgentSourceWorktreeReference;
+    commit?: AgentCommitReference;
+    verification: AgentVerificationResult[];
+    citations: ResearchCitation[];
+    signals: AgentSignal[];
+    controlPlaneReferences?: AgentControlPlaneReference[];
+    usage: ExecutionUsageActual[];
+    diagnostics: AgentDiagnosticReference[];
+    createdAt: string;
+}
+export declare function validateAgentArtifactManifest(manifest: AgentArtifactManifest, expected?: {
+    publishedSignals?: unknown;
+    artifactContracts?: unknown;
+    signalContracts?: unknown;
+}): {
+    ok: false;
+    reason: string;
+} | {
+    ok: true;
+    reason?: undefined;
+};

package/dist/agent-capacity/artifacts.js

@@ -0,0 +1,39 @@
+import { validateResearchCitations } from "./validation/research/citation.js";
+import { validateArtifactMutationReceipt } from "./artifact-mutation-receipt.js";
+function validateAgentArtifactManifest(manifest, expected = {}) {
+  const invalidReceipt = (manifest.mutationReceipts ?? []).find((receipt) => {
+    const validation = validateArtifactMutationReceipt(receipt);
+    return !validation.ok || receipt.assignmentId !== manifest.assignmentId || receipt.modeRunId !== manifest.modeRunId || receipt.teamId !== manifest.teamId || receipt.projectId !== manifest.projectId;
+  });
+  if (invalidReceipt) return { ok: false, reason: "Artifact mutation receipt is invalid or outside the manifest authority scope." };
+  if ((manifest.artifactReferences ?? []).some((reference) => reference.contract !== "treeseed.artifact-ref/v1" || typeof reference.sha256 === "string" && !/^[0-9a-f]{64}$/u.test(reference.sha256) || "signedUrl" in reference || "credentials" in reference)) {
+    return { ok: false, reason: "Artifact references must be stable, digest-addressed, and secret-free." };
+  }
+  const citationValidation = validateResearchCitations(manifest.citations, "artifactManifest.citations");
+  if (!citationValidation.ok) {
+    return { ok: false, reason: citationValidation.diagnostics.map((diagnostic) => `${diagnostic.code} at ${diagnostic.path}`).join(", ") };
+  }
+  if (manifest.status !== "completed") return { ok: true };
+  const ids = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && Boolean(entry.trim())).map((entry) => entry.replace(/_/gu, "-")) : [];
+  const producedSignals = new Set(manifest.signals.map((signal) => signal.code.replace(/_/gu, "-")));
+  const requestedSignals = [...ids(expected.publishedSignals), ...ids(expected.signalContracts)];
+  const missingSignals = requestedSignals.filter((id) => !producedSignals.has(id));
+  if (missingSignals.length) return {
+    ok: false,
+    reason: `Completed agent execution omitted validated publications: ${missingSignals.map((id) => `signal:${id}`).join(", ")}.`
+  };
+  const producedArtifacts = new Set(manifest.contentReferences.map((reference) => reference.artifactKind?.replace(/_/gu, "-")).filter(Boolean));
+  const missingArtifacts = ids(expected.artifactContracts).filter((id) => !producedArtifacts.has(id));
+  if (missingArtifacts.length) return {
+    ok: false,
+    reason: `Completed agent execution omitted validated publications: ${missingArtifacts.map((id) => `artifact:${id}`).join(", ")}.`
+  };
+  if (manifest.contentReferences.some((reference) => reference.model === "note" && (!reference.subjectId || !reference.subjectField))) {
+    return { ok: false, reason: "Completed note receipt is missing its validated subject link." };
+  }
+  if (manifest.contentReferences.length || manifest.sourceWorktree || manifest.verification.length || manifest.controlPlaneReferences?.length) return { ok: true };
+  return { ok: false, reason: "Completed agent execution did not produce a TreeDX content receipt, durable control-plane output, source worktree change, or verification result." };
+}
+export {
+  validateAgentArtifactManifest
+};

package/dist/agent-capacity/authoring/agent-definition-authoring.d.ts

@@ -0,0 +1,57 @@
+import type { AgentActivityProfilesConfiguration, AgentContentRevisionRef } from '../../types/agents/agent-activity-profile.js';
+export declare const AGENT_RUNTIME_STATUSES: readonly ["dormant", "blocked", "queued", "running", "waiting", "degraded", "idle"];
+export type AgentRuntimeStatus = (typeof AGENT_RUNTIME_STATUSES)[number];
+export type AgentDesignMaturity = 'draft' | 'validated' | 'simulated' | 'proven';
+export interface AgentAuthoringIntent {
+    name: string;
+    description: string;
+    purpose: string;
+    responsibilities: string[];
+    durableInstructions: string;
+    agentClass: string;
+    template?: string;
+    enabled: boolean;
+    designMaturity?: AgentDesignMaturity;
+    activityProfiles: AgentActivityProfilesConfiguration;
+    groupIds?: string[];
+    topicIds?: string[];
+    contextQueryRefs?: AgentContentRevisionRef[];
+    contextQuerySetRefs?: AgentContentRevisionRef[];
+    instructionTemplateRefs?: AgentContentRevisionRef[];
+}
+export interface LockedAgentIdentity {
+    id: string;
+    slug: string;
+    path: string;
+    createdAt?: string;
+    createdFromTemplate?: string;
+}
+export interface CompiledAgentDefinition {
+    identity: LockedAgentIdentity;
+    frontmatter: Record<string, unknown>;
+    generated: {
+        projectAgentClassId: string;
+        projectAgentClassSlug: string;
+        groupIds: string[];
+    };
+}
+export interface AgentRuntimeEvidence {
+    enabled: boolean;
+    valid?: boolean;
+    syncBlocked?: boolean;
+    hardBlocked?: boolean;
+    activeRunStatus?: string | null;
+    assignmentStatus?: string | null;
+    latestTerminalStatus?: string | null;
+    settlementIssue?: boolean;
+}
+export declare function deriveAgentRuntimeStatus(evidence: AgentRuntimeEvidence): AgentRuntimeStatus;
+export declare function compileAgentDefinition(input: {
+    intent: AgentAuthoringIntent;
+    projectId: string;
+    contentRoot?: string;
+    existing?: {
+        identity: LockedAgentIdentity;
+        frontmatter?: Record<string, unknown>;
+    };
+}): CompiledAgentDefinition;

package/dist/agent-capacity/authoring/agent-definition-authoring.js

@@ -0,0 +1,73 @@
+const AGENT_RUNTIME_STATUSES = ["dormant", "blocked", "queued", "running", "waiting", "degraded", "idle"];
+function slug(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-|-$/gu, "");
+}
+function unique(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function revisionRefs(values) {
+  if (!Array.isArray(values)) return [];
+  const refs = values.flatMap((value) => value && typeof value === "object" && !Array.isArray(value) && typeof value.id === "string" && Number.isInteger(value.revision) ? [{ id: String(value.id).trim(), revision: Number(value.revision) }] : []);
+  return [...new Map(refs.map((ref) => [`${ref.id}@${ref.revision}`, ref])).values()];
+}
+function deriveAgentRuntimeStatus(evidence) {
+  if (!evidence.enabled) return "dormant";
+  if (evidence.valid === false || evidence.syncBlocked || evidence.hardBlocked) return "blocked";
+  if (evidence.activeRunStatus === "running") return "running";
+  if (["waiting", "retrying", "awaiting_human", "awaiting_external"].includes(evidence.activeRunStatus ?? "")) return "waiting";
+  if (["pending", "admitted", "leased", "queued"].includes(evidence.assignmentStatus ?? "")) return "queued";
+  if (["failed", "expired", "returned"].includes(evidence.latestTerminalStatus ?? "") || evidence.settlementIssue) return "degraded";
+  return "idle";
+}
+function compileAgentDefinition(input) {
+  const agentSlug = input.existing?.identity.slug || slug(input.intent.name);
+  const classSlug = slug(input.intent.agentClass) || "planning";
+  if (!agentSlug) throw new Error("Agent name must produce a stable identity.");
+  const identity = input.existing?.identity ?? {
+    id: `agent:${agentSlug}`,
+    slug: agentSlug,
+    path: `${(input.contentRoot ?? "src/content").replace(/^\/+|\/+$/gu, "")}/agents/${agentSlug}.mdx`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdFromTemplate: input.intent.template
+  };
+  const prior = input.existing?.frontmatter ?? {};
+  const legacyField = ["primaryGroupId", "permissionPolicy", "contentAccess"].find((field) => field in prior);
+  if (legacyField) throw new Error(`Existing agent definition uses removed field ${legacyField}. Migrate it before authoring a revision.`);
+  const priorGroups = Array.isArray(prior.groupIds) ? prior.groupIds.map(String) : [];
+  const groupIds = unique([...priorGroups, ...input.intent.groupIds ?? []]);
+  if (!groupIds.length) groupIds.push("group:project");
+  const frontmatter = {
+    ...prior,
+    id: identity.id,
+    slug: identity.slug,
+    title: input.intent.name.trim(),
+    name: input.intent.name.trim(),
+    agentClass: classSlug,
+    projectAgentClassId: classSlug,
+    projectAgentClassSlug: classSlug,
+    template: input.intent.template || prior.template,
+    enabled: input.intent.enabled,
+    description: input.intent.description.trim(),
+    summary: input.intent.description.trim(),
+    designMaturity: input.intent.designMaturity ?? prior.designMaturity ?? "draft",
+    groupIds,
+    topicIds: unique(input.intent.topicIds ?? (Array.isArray(prior.topicIds) ? prior.topicIds.map(String) : [])),
+    contextQueryRefs: revisionRefs(input.intent.contextQueryRefs ?? prior.contextQueryRefs),
+    contextQuerySetRefs: revisionRefs(input.intent.contextQuerySetRefs ?? prior.contextQuerySetRefs),
+    instructionTemplateRefs: revisionRefs(input.intent.instructionTemplateRefs ?? prior.instructionTemplateRefs),
+    identity: {
+      purpose: input.intent.purpose.trim(),
+      responsibilities: unique(input.intent.responsibilities),
+      durableInstructions: input.intent.durableInstructions.trim()
+    },
+    activityProfiles: input.intent.activityProfiles
+  };
+  delete frontmatter.runtimeStatus;
+  delete frontmatter.execution;
+  return { identity, frontmatter, generated: { projectAgentClassId: classSlug, projectAgentClassSlug: classSlug, groupIds } };
+}
+export {
+  AGENT_RUNTIME_STATUSES,
+  compileAgentDefinition,
+  deriveAgentRuntimeStatus
+};

package/dist/agent-capacity/authoring/agent-deployment.d.ts

@@ -0,0 +1,93 @@
+export type AgentDeploymentEntityKind = 'agent' | 'group' | 'group-edge' | 'context-query' | 'context-query-set' | 'instruction-template' | 'discussion-topic' | 'signal' | 'proposal-type' | 'agent-test';
+export type AgentDeploymentSelector = {
+    sourceTeamId: string;
+    sourceProjectId: string;
+    sourceRepositoryId: string;
+    sourceRef: string;
+    agentId: string;
+    groupId?: never;
+} | {
+    sourceTeamId: string;
+    sourceProjectId: string;
+    sourceRepositoryId: string;
+    sourceRef: string;
+    groupId: string;
+    agentId?: never;
+};
+export interface AgentDeploymentBindings {
+    targetProjectId: string;
+    targetContentRoot: string;
+    repositoryRoles?: Record<string, string>;
+    paths?: Record<string, string>;
+    books?: Record<string, string>;
+    objectives?: Record<string, string>;
+    topics?: Record<string, string>;
+    groups?: Record<string, string>;
+    providerCapabilities?: Record<string, string>;
+}
+export interface AgentForkProvenance {
+    sourceTeamId: string;
+    sourceProjectId: string;
+    sourceEntityId: string;
+    sourcePath: string;
+    sourceRef: string;
+    sourceDigest: string;
+    deploymentId: string;
+    generation: string;
+    lastImportedSourceRef: string;
+    targetBaseRef: string;
+}
+export interface PortableAgentDeploymentEntity {
+    kind: AgentDeploymentEntityKind;
+    id: string;
+    path: string;
+    source: string;
+    digest: string;
+    references: string[];
+    groupIds?: string[];
+    enabled?: boolean;
+}
+export interface AgentDeploymentTargetEntity extends PortableAgentDeploymentEntity {
+    targetPath: string;
+    action: 'create' | 'noop' | 'conflict';
+    provenance: AgentForkProvenance;
+    sourceEnabled?: boolean;
+    diagnostics: string[];
+}
+export interface AgentDeploymentPlan {
+    schemaVersion: 'treeseed.agent-deployment-plan/v1';
+    id: string;
+    selector: AgentDeploymentSelector;
+    bindings: AgentDeploymentBindings;
+    sourceGeneration: string;
+    targetBaseRef: string;
+    selectedAgentIds: string[];
+    entities: AgentDeploymentTargetEntity[];
+    unresolvedBindings: string[];
+    conflicts: string[];
+    activationPrerequisites: string[];
+    ok: boolean;
+}
+export interface AgentDeploymentReceipt {
+    schemaVersion: 'treeseed.agent-deployment-receipt/v1';
+    deploymentId: string;
+    targetProjectId: string;
+    beforeRef: string;
+    afterRef: string;
+    changedPaths: string[];
+    definitionDigests: Record<string, string>;
+    tests: string[];
+    readBackVerified: boolean;
+    activationState: 'dormant' | 'active' | 'blocked';
+    createdAt: string;
+}
+export declare function compileDormantAgentForkSource(entity: PortableAgentDeploymentEntity, provenance: AgentForkProvenance): string;
+export declare function planAgentDeployment(input: {
+    selector: AgentDeploymentSelector;
+    bindings: AgentDeploymentBindings;
+    entities: PortableAgentDeploymentEntity[];
+    targetBaseRef: string;
+    targetEntities?: PortableAgentDeploymentEntity[];
+    generation: string;
+    deploymentId?: string;
+}): AgentDeploymentPlan;

package/dist/agent-capacity/authoring/agent-deployment.js

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+import { parseFrontmatterDocument, serializeFrontmatterDocument } from "../../content/frontmatter.js";
+function digest(value) {
+  return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function exact(value) {
+  return value.trim() && !/^(?:HEAD|main|master|staging|latest)$/iu.test(value.trim());
+}
+function targetPath(entity, bindings) {
+  const content = bindings.targetContentRoot.replace(/^\/+|\/+$/gu, "");
+  const marker = "/src/content/";
+  const docsMarker = "/docs/src/content/";
+  const index = entity.path.indexOf(docsMarker) >= 0 ? entity.path.indexOf(docsMarker) + docsMarker.length : entity.path.indexOf(marker) >= 0 ? entity.path.indexOf(marker) + marker.length : -1;
+  if (index >= 0) return `${content}/${entity.path.slice(index)}`;
+  return entity.path;
+}
+function requiredBindingRefs(entity, bindings) {
+  return entity.references.filter((reference) => reference.startsWith("book:") && !bindings.books?.[reference] || reference.startsWith("objective:") && !bindings.objectives?.[reference] || reference.startsWith("topic:") && !bindings.topics?.[reference] || reference.startsWith("repository-role:") && !bindings.repositoryRoles?.[reference] || reference.startsWith("provider-capability:") && !bindings.providerCapabilities?.[reference]);
+}
+function compileDormantAgentForkSource(entity, provenance) {
+  if (entity.kind !== "agent") return entity.source;
+  const parsed = parseFrontmatterDocument(entity.source);
+  const frontmatter = { ...parsed.frontmatter, enabled: false, forkProvenance: provenance };
+  return serializeFrontmatterDocument(frontmatter, parsed.body);
+}
+function planAgentDeployment(input) {
+  if (!exact(input.selector.sourceRef) || !exact(input.targetBaseRef)) throw new Error("Agent deployment requires exact source and target refs.");
+  if (Boolean(input.selector.agentId) === Boolean(input.selector.groupId)) throw new Error("Choose exactly one agent or group selector.");
+  const byId = new Map(input.entities.map((entity) => [entity.id, entity]));
+  const selectedAgents = input.selector.agentId ? [input.selector.agentId] : input.entities.filter((entity) => entity.kind === "agent" && entity.groupIds?.includes(input.selector.groupId)).map((entity) => entity.id).sort();
+  if (!selectedAgents.length) throw new Error("The deployment selector resolved no agents.");
+  const selected = new Set(selectedAgents);
+  if (input.selector.groupId) selected.add(input.selector.groupId);
+  const queue = [...selected];
+  while (queue.length) {
+    const entity = byId.get(queue.shift());
+    if (!entity) continue;
+    for (const reference of entity.references) if (byId.has(reference) && !selected.has(reference)) {
+      selected.add(reference);
+      queue.push(reference);
+    }
+  }
+  const deploymentId = input.deploymentId ?? `agent-deployment:${digest(`${input.selector.sourceProjectId}:${input.selector.sourceRef}:${selectedAgents.join(",")}:${input.bindings.targetProjectId}`).slice(7, 31)}`;
+  const targetByPath = new Map((input.targetEntities ?? []).map((entity) => [entity.path, entity]));
+  const unresolvedBindings = [];
+  const conflicts = [];
+  const entities = [...selected].map((id) => byId.get(id)).filter((entity) => Boolean(entity)).sort((a, b) => a.path.localeCompare(b.path)).map((entity) => {
+    const path = targetPath(entity, input.bindings);
+    const existing = targetByPath.get(path);
+    const unresolved = requiredBindingRefs(entity, input.bindings);
+    unresolvedBindings.push(...unresolved.map((binding) => `${entity.id}:${binding}`));
+    const provenance = { sourceTeamId: input.selector.sourceTeamId, sourceProjectId: input.selector.sourceProjectId, sourceEntityId: entity.id, sourcePath: entity.path, sourceRef: input.selector.sourceRef, sourceDigest: entity.digest, deploymentId, generation: input.generation, lastImportedSourceRef: input.selector.sourceRef, targetBaseRef: input.targetBaseRef };
+    const source = compileDormantAgentForkSource(entity, provenance);
+    const sourceDigest = digest(source);
+    const action = !existing ? "create" : existing.digest === sourceDigest ? "noop" : "conflict";
+    if (action === "conflict") conflicts.push(path);
+    return { ...entity, source, digest: sourceDigest, targetPath: path, action, provenance, sourceEnabled: entity.enabled, diagnostics: unresolved };
+  });
+  const activationPrerequisites = ["schema-and-reference-validation", "dynamic-context-tests", "permission-and-path-fit", "signal-and-proposal-contracts", "provider-capabilities", "profile-forbidden-authority-tests", "unchanged-source-and-target-refs"];
+  return { schemaVersion: "treeseed.agent-deployment-plan/v1", id: deploymentId, selector: input.selector, bindings: input.bindings, sourceGeneration: input.generation, targetBaseRef: input.targetBaseRef, selectedAgentIds: selectedAgents, entities, unresolvedBindings: [...new Set(unresolvedBindings)].sort(), conflicts: [...new Set(conflicts)].sort(), activationPrerequisites, ok: unresolvedBindings.length === 0 && conflicts.length === 0 };
+}
+export {
+  compileDormantAgentForkSource,
+  planAgentDeployment
+};

package/dist/agent-capacity/authoring/chat-activity-profile.d.ts

@@ -0,0 +1,2 @@
+import type { AgentActivityProfile, AgentChatProfileConfiguration } from '../../types/agents/agent-activity-profile.js';
+export declare function compileDefaultChatActivityProfile(agentSlug: string, specialization?: AgentChatProfileConfiguration): AgentActivityProfile;

package/dist/agent-capacity/authoring/chat-activity-profile.js

@@ -0,0 +1,91 @@
+function compileDefaultChatActivityProfile(agentSlug, specialization = { foundation: "discussion-v1" }) {
+  const writableModels = /* @__PURE__ */ new Set(["note", "question", "proposal", "assignment_plan", "assignment_status", "assignment_summary"]);
+  const contextModels = [.../* @__PURE__ */ new Set([
+    "discussion",
+    "discussion_message",
+    "discussion_event",
+    "discussion_topic",
+    "agent",
+    "note",
+    "question",
+    "proposal",
+    "decision",
+    "objective",
+    "knowledge",
+    "assignment_plan",
+    "assignment_status",
+    "assignment_summary",
+    ...specialization.contextModels ?? []
+  ])];
+  const tools = [.../* @__PURE__ */ new Set([
+    "treeseed.content.describe",
+    "treeseed.content.query",
+    "treeseed.content.read",
+    "treedx.build_context",
+    "treedx.read_repository_files",
+    "treedx.search_workspace",
+    "treedx.read_workspace_file",
+    "treeseed.content.create",
+    "treeseed.content.update",
+    "treeseed.content.link",
+    "treeseed.content.validate",
+    "treeseed.content.commit",
+    "treeseed.status",
+    "treeseed.assignment_activity",
+    "treeseed.assignment_plan",
+    "treeseed.assignment_status_update",
+    "treeseed.assignment_summary",
+    "treeseed.discussion.read",
+    "treeseed.discussion.follow",
+    "treeseed.discussion.respond",
+    "treeseed.discussion.request_handoff",
+    "treeseed.discussion.create_artifact",
+    "treeseed.operation.prepare_handoff",
+    "treeseed.client_session.request_action",
+    ...specialization.toolAdditions ?? []
+  ])];
+  return {
+    enabled: true,
+    handler: "writer",
+    prompt: {
+      system: `Participate as ${agentSlug} in a TreeSeed Discussion. Answer from your configured identity and durable instructions, cite exact TreeDX content or repository refs, distinguish evidence from inference, and keep the response scoped to the current turn. You may create or update discussion messages, linked notes, questions, and proposals. Never change knowledge or code without an approved governed acting assignment.${specialization.responseStyle ? ` Response style: ${specialization.responseStyle}` : ""}`,
+      task: specialization.promptTask ?? "Respond to the committed Discussion turn and produce durable, source-grounded output."
+    },
+    branchPolicy: { kind: "staging-content", base: "staging" },
+    permissions: {
+      content: Object.fromEntries(contextModels.map((model) => [model, {
+        operations: writableModels.has(model) ? ["describe", "query", "read", "create", "update", "link", "validate", "commit"] : ["describe", "query", "read"]
+      }])),
+      commit: { allowed: true }
+    },
+    tools: { allowed: tools },
+    outputs: {
+      messageTypes: ["discussion_response"],
+      modelMutations: ["discussion_message:create", "linked_note:create", "question:create", "proposal:create"]
+    },
+    planningIntent: {
+      stage: "deliberation",
+      objective: "Respond to the exact committed Discussion turn with a durable, correctly addressed message.",
+      artifactKind: "discussion_response",
+      subjectModel: "discussion_message",
+      subjectId: null
+    },
+    questionPolicy: { blockExecutionWhenCreated: false, defaultAnswerPolicy: { kind: "team-human" } },
+    execution: {
+      requiredCapabilities: specialization.requiredCapabilities ?? ["agent-execution"],
+      maxRuntimeSeconds: specialization.maxRuntimeSeconds ?? 900,
+      maxRetries: 1,
+      verificationRequired: false,
+      maxTotalTokens: specialization.maxTotalTokens ?? 136e3,
+      warningTokens: specialization.warningTokens ?? 1e5,
+      maxCostAmount: specialization.maxCostAmount,
+      costCurrency: specialization.costCurrency ?? "USD",
+      pricingGeneration: "provider-runtime",
+      enforcementConfidence: "bounded",
+      closeoutWarningSeconds: 180
+    }
+  };
+}
+export {
+  compileDefaultChatActivityProfile
+};

package/dist/agent-capacity/authoring/group-definition-authoring.d.ts

@@ -0,0 +1,33 @@
+import { type GovernanceGroup, type GovernanceGroupEdge } from "../../governance/groups/contracts.js";
+export interface GroupAuthoringIntent {
+    name: string;
+    description: string;
+    classification: string;
+    aliases?: string[];
+    parentGroupId?: string;
+    coordination?: GovernanceGroup['coordination'];
+}
+export declare function compileGroupDefinition(input: {
+    intent: GroupAuthoringIntent;
+    contentRoot: string;
+    existingId?: string;
+}): {
+    group: GovernanceGroup;
+    edge: GovernanceGroupEdge | null;
+    groupPath: string;
+    edgePath: string | null;
+};
+export declare function validateGroupDefinition(value: unknown): {
+    ok: boolean;
+    diagnostics: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+export declare function validateGroupEdgeDefinition(value: unknown): {
+    ok: boolean;
+    diagnostics: Array<{
+        path: string;
+        message: string;
+    }>;
+};