@treeseed/sdk 0.13.0-rc.2 → 0.13.0-rc.21

package/dist/reconcile/seeds/local-seed-bootstrap-adapter.js

@@ -1,213 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { resolve } from "node:path";
-import { parse as parseYaml } from "yaml";
-import { reconcileLocalSeedRuntime } from "../../seeds/runtime/local-capacity.js";
-const LOCAL_SEED_ACCESS_TOKEN = "tsk_local_treeseed_acceptance_admin";
-function text(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function count(summary, key) {
-  const value = Number(summary[key] ?? 0);
-  return Number.isFinite(value) && value >= 0 ? value : 0;
-}
-function pendingMutations(summary) {
-  return count(summary, "create") + count(summary, "update") + count(summary, "error");
-}
-function providerManifestDrift(input) {
-  const configured = Array.isArray(input.unit.spec.providerManifests) ? input.unit.spec.providerManifests : [];
-  return configured.flatMap((candidate) => {
-    const item = record(candidate);
-    const basePath = resolve(input.context.tenantRoot, text(item.baseManifestPath) ?? "");
-    const runtimePath = resolve(input.context.tenantRoot, text(item.runtimeManifestPath) ?? "");
-    const seedName = text(item.seedName);
-    if (!existsSync(basePath) || !existsSync(runtimePath)) return [{ basePath, runtimePath, seedName, reason: "runtime_manifest_missing" }];
-    try {
-      const runtime = parseYaml(readFileSync(runtimePath, "utf8"));
-      const observed = text(record(runtime.configuration).sourceManifestDigest);
-      const expected = text(item.manifestDigest);
-      return observed === expected ? [] : [{ basePath, runtimePath, seedName, reason: "runtime_manifest_stale", expected, observed }];
-    } catch (error) {
-      return [{ basePath, runtimePath, seedName, reason: "runtime_manifest_invalid", error: error instanceof Error ? error.message : String(error) }];
-    }
-  });
-}
-function localSeedAccessToken(input) {
-  return text(input.context.launchEnv.TREESEED_CAPACITY_ACCEPTANCE_ADMIN_TOKEN) ?? LOCAL_SEED_ACCESS_TOKEN;
-}
-async function loadSeedModule(input) {
-  const modulePath = text(input.unit.spec.applyModulePath);
-  if (!modulePath || !existsSync(modulePath)) throw new Error(`Local seed apply module is missing: ${modulePath ?? "<unset>"}.`);
-  let loaded;
-  try {
-    if (modulePath.endsWith(".ts")) {
-      const tsxApiModule = "tsx/esm/api";
-      const api = await import(tsxApiModule);
-      loaded = await api.tsImport(modulePath, import.meta.url);
-    } else {
-      loaded = await import(pathToFileURL(modulePath).href);
-    }
-  } catch (sourceError) {
-    const compiledPath = text(input.unit.spec.compiledApplyModulePath);
-    if (!compiledPath || !existsSync(compiledPath)) throw sourceError;
-    loaded = await import(pathToFileURL(compiledPath).href);
-  }
-  if (typeof loaded.planLocalSeedFromCli !== "function" || typeof loaded.applyLocalSeedFromCli !== "function") {
-    throw new Error(`Local seed module ${modulePath} does not expose the canonical plan/apply operations.`);
-  }
-  return loaded;
-}
-function seedInput(input) {
-  const accessToken = localSeedAccessToken(input);
-  return {
-    projectRoot: input.context.tenantRoot,
-    seedName: text(input.unit.spec.seedName) ?? "treeseed",
-    environments: text(input.unit.spec.environments) ?? "local",
-    env: {
-      ...input.context.launchEnv,
-      TREESEED_CAPACITY_ACCEPTANCE_ADMIN_TOKEN: accessToken
-    },
-    accessToken
-  };
-}
-async function applySeed(input, module, seedName) {
-  let applied;
-  try {
-    applied = record(await module.applyLocalSeedFromCli({
-      ...seedInput(input),
-      seedName,
-      mode: "apply",
-      localOnly: true,
-      actor: { actorType: "service", id: "local-seed-reconciler" }
-    }));
-  } catch (error) {
-    throw new Error(`Local seed content reconciliation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-  }
-  const plan = applied.plan;
-  let runtime = { providers: [], servicePrincipals: [] };
-  if (plan) {
-    try {
-      runtime = await reconcileLocalSeedRuntime({
-        projectRoot: input.context.tenantRoot,
-        plan,
-        accessToken: localSeedAccessToken(input),
-        apiUrl: localSeedHostApiUrl(input),
-        env: seedInput(input).env
-      });
-    } catch (error) {
-      throw new Error(`Local seed capacity runtime reconciliation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-  }
-  return { seedName, result: record(applied.result), runtime };
-}
-function localSeedHostApiUrl(input) {
-  return text(input.unit.spec.apiUrl) ?? "http://127.0.0.1:3000";
-}
-async function observe(input) {
-  try {
-    const module = await loadSeedModule(input);
-    const planned = record(await module.planLocalSeedFromCli({ ...seedInput(input), mode: "plan" }));
-    const plan = record(planned.plan);
-    const summary = record(plan.summary);
-    const pending = pendingMutations(summary);
-    const providerManifestDrifts = providerManifestDrift(input);
-    return {
-      exists: true,
-      status: pending === 0 && providerManifestDrifts.length === 0 ? "ready" : "drifted",
-      live: {
-        seedName: text(input.unit.spec.seedName) ?? "treeseed",
-        manifestDigest: text(input.unit.spec.manifestDigest),
-        summary,
-        pendingMutations: pending + providerManifestDrifts.length,
-        seedPendingMutations: pending,
-        providerManifestDrifts
-      },
-      locators: { manifestPath: text(input.unit.spec.manifestPath) },
-      warnings: []
-    };
-  } catch (error) {
-    return {
-      exists: false,
-      status: "error",
-      live: {},
-      locators: { manifestPath: text(input.unit.spec.manifestPath) },
-      warnings: [error instanceof Error ? error.message : String(error)]
-    };
-  }
-}
-function result(input, state) {
-  return {
-    unit: input.unit,
-    observed: input.observed,
-    diff: input.diff,
-    action: input.diff.action,
-    warnings: input.observed.warnings,
-    resourceLocators: input.observed.locators,
-    state,
-    verification: null
-  };
-}
-function createLocalSeedBootstrapAdapter() {
-  return {
-    providerId: "local",
-    unitTypes: ["local-seed-bootstrap"],
-    supports: (unitType, providerId) => unitType === "local-seed-bootstrap" && providerId === "local",
-    refresh: observe,
-    diff(input) {
-      if (input.observed.status === "error") {
-        return { action: "blocked", reasons: input.observed.warnings, before: input.observed.live, after: input.unit.spec };
-      }
-      const pending = Number(input.observed.live.pendingMutations ?? 0);
-      return pending > 0 ? { action: "update", reasons: [`${pending} local seed mutations remain`], before: input.observed.live, after: input.unit.spec } : { action: "noop", reasons: [], before: input.observed.live, after: input.unit.spec };
-    },
-    async apply(input) {
-      if (input.diff.action === "noop" || input.diff.action === "blocked") return result(input, input.observed.live);
-      const module = await loadSeedModule(input);
-      const primarySeedName = text(input.unit.spec.seedName) ?? "treeseed";
-      const providerSeedNames = (Array.isArray(input.observed.live.providerManifestDrifts) ? input.observed.live.providerManifestDrifts : []).map((entry) => text(record(entry).seedName)).filter((seedName) => Boolean(seedName));
-      const seedNames = [.../* @__PURE__ */ new Set([primarySeedName, ...providerSeedNames])];
-      const applications = [];
-      for (const seedName of seedNames) applications.push(await applySeed(input, module, seedName));
-      const converged = await observe(input);
-      if (converged.status !== "ready" || Number(converged.live.pendingMutations ?? 0) !== 0) {
-        throw new Error(`Local seed apply did not converge: ${Number(converged.live.pendingMutations ?? 0)} mutation(s) remain.`);
-      }
-      const primary = applications.find((entry) => entry.seedName === primarySeedName);
-      return result(input, { ...converged.live, applied: primary?.result ?? {}, runtime: primary?.runtime ?? { providers: [] }, applications });
-    },
-    async verify(input) {
-      const pending = Number(input.observed.live.pendingMutations ?? 0);
-      const verified = input.observed.status === "ready" && pending === 0;
-      return {
-        unitId: input.unit.unitId,
-        supported: true,
-        exists: input.observed.exists,
-        configured: true,
-        ready: verified,
-        verified,
-        checks: [{
-          key: "local-seed.converged",
-          description: "Local seed desired state is fully converged",
-          source: "sdk",
-          exists: input.observed.exists,
-          configured: true,
-          ready: verified,
-          verified,
-          expected: 0,
-          observed: pending,
-          issues: verified ? [] : [`${pending} seed mutations remain.`]
-        }],
-        missing: input.observed.exists ? [] : ["Local seed plan is unavailable."],
-        drifted: verified ? [] : ["Local seed desired state is not converged."],
-        warnings: input.observed.warnings
-      };
-    }
-  };
-}
-export {
-  createLocalSeedBootstrapAdapter,
-  localSeedHostApiUrl
-};

package/dist/reconcile/support/acceptance/live-acceptance-starter-concurrency.d.ts

@@ -1,19 +0,0 @@
-import { MarketClient } from '../../../entrypoints/clients/market-client.js';
-import type { CapacityAcceptanceProof } from '../../capacity/capacity-core/live-acceptance-capacity-context.js';
-import type { CapacityAcceptanceExecutionInput } from '../../capacity/capacity-core/live-acceptance-capacity-executor.js';
-import type { CapacityGovernanceRuntimeConnection } from '../../capacity/capacity-core/live-acceptance-capacity-governance.js';
-import type { RunLiveReconcileTestsOptions } from './live-acceptance.js';
-export declare function concurrentProjectClassTransitionKey(runId: string, projectId: string, transition: string, classSlug: string): string;
-export declare function hasConcurrentUsageAndExactlyOnceSettlement(terminals: Array<{
-    usageActualCount: number;
-    ledgerEntryCount: number;
-}>): boolean;
-export declare function runLocalConcurrentStarterAcceptance(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    fetchImpl: typeof fetch;
-    privateJwk: CapacityAcceptanceExecutionInput['privateJwk'];
-    executor: NonNullable<RunLiveReconcileTestsOptions['capacityAssignmentExecutor']>;
-}): Promise<NonNullable<CapacityAcceptanceProof['starterConcurrency']>>;

package/dist/reconcile/support/acceptance/live-acceptance-starter-concurrency.js

@@ -1,128 +0,0 @@
-import { resolve } from "node:path";
-import { runGitText } from "../../../operations/services/operations/git-runner.js";
-import { verifyCapacityAcceptanceTerminal } from "../../capacity/capacity-core/live-acceptance-capacity-terminal.js";
-import { finalizeLocalStarterAcceptance, provisionLocalStarterPortfolioCapacity } from "../../runtime/live-acceptance-starter-runtime.js";
-import { engineeringStarterCapacityConfig } from "./live-acceptance-starter-engineering.js";
-import { researchStarterCapacityConfig } from "./live-acceptance-starter-planning.js";
-const DECISION_ID = "normalize-release-channel-inputs";
-function concurrentProjectClassTransitionKey(runId, projectId, transition, classSlug) {
-  return `concurrent-starters:${runId}:project:${projectId}:${transition}:${classSlug}`;
-}
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function timestamp(value) {
-  const parsed = Date.parse(String(value ?? ""));
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-function workspaceId(assignment) {
-  return String(record(assignment.treedxProxyHandle).workspaceId ?? record(record(assignment.workspaceContext).treedxProxyHandle).workspaceId ?? "");
-}
-function hasConcurrentUsageAndExactlyOnceSettlement(terminals) {
-  return terminals.every((terminal) => terminal.usageActualCount > 0 && terminal.ledgerEntryCount === 1);
-}
-async function runLocalConcurrentStarterAcceptance(input) {
-  const engineeringRoot = resolve(process.cwd(), "starters/engineering");
-  const exactBaseRef = runGitText(["rev-parse", "HEAD"], { cwd: engineeringRoot, mode: "read" }).trim();
-  if (!/^[a-f0-9]{40}$/u.test(exactBaseRef)) throw new Error("Concurrent starter acceptance could not resolve the engineering exact source commit.");
-  const portfolio = await provisionLocalStarterPortfolioCapacity({
-    ...input,
-    configs: [engineeringStarterCapacityConfig(`${input.runId}-concurrent`, exactBaseRef), researchStarterCapacityConfig()]
-  });
-  const engineering = portfolio.projects[0];
-  const research = portfolio.projects[1];
-  let executionError;
-  try {
-    for (const classSlug of ["engineering", "release", "reporting", "research", "review", "technical-writing", "testing"]) {
-      await input.adminClient.updateProjectAgentClass(engineering.project.id, `${engineering.project.id}:${classSlug}`, { status: "paused" }, concurrentProjectClassTransitionKey(input.runId, engineering.project.id, "pause", classSlug));
-    }
-    await input.adminClient.updateProjectAgentClass(engineering.project.id, `${engineering.project.id}:architecture`, { status: "active", allowedModes: ["planning"] }, concurrentProjectClassTransitionKey(input.runId, engineering.project.id, "activate", "architecture"));
-    await Promise.all([
-      input.adminClient.updateProjectAgentClass(research.project.id, `${research.project.id}:research`, { status: "active", allowedModes: ["planning"] }, concurrentProjectClassTransitionKey(input.runId, research.project.id, "activate", "research")),
-      ...["review", "technical-writing", "reporting"].map((classSlug) => input.adminClient.updateProjectAgentClass(research.project.id, `${research.project.id}:${classSlug}`, { status: "paused", allowedModes: ["planning"] }, concurrentProjectClassTransitionKey(input.runId, research.project.id, "pause", classSlug)))
-    ]);
-    await input.adminClient.createPlanningInputRequest(DECISION_ID, {
-      id: `concurrent-engineering-proposal:${input.runId}`,
-      projectId: engineering.project.id,
-      projectAgentClassId: `${engineering.project.id}:architecture`,
-      mode: "planning",
-      prompt: "Create the linked test-first release-channel proposal.",
-      metadata: { agentId: "architect", objectiveId: "ship-the-first-guided-change", planningSource: "concurrent-live-proposal", priority: 100 }
-    });
-    const workflowId = `concurrent-research:${input.runId}`;
-    await input.adminClient.createResearchWorkflow(research.project.id, {
-      id: workflowId,
-      objectiveRef: "objective:publish-the-first-knowledge-pack",
-      questionRef: "question:what-should-this-research-map-first",
-      minimumIndependentSources: 2,
-      maxRevisionCycles: 3,
-      idempotencyKey: `${workflowId}:create`,
-      metadata: { liveAcceptance: true, concurrentStarters: true }
-    });
-    await Promise.all(portfolio.workdayRunIds.map((runId, index) => input.adminClient.tickWorkdayRun(input.runtime.teamId, runId, {
-      idempotencyKey: `concurrent-starters:${input.runId}:tick:${index}`
-    })));
-    const execution = await input.executor({
-      runId: `${input.runId}-concurrent-starters`,
-      apiUrl: input.apiUrl,
-      teamId: portfolio.connection.teamId,
-      projectId: engineering.project.id,
-      providerId: portfolio.connection.providerId,
-      membershipId: portfolio.connection.membershipId,
-      credentialId: portfolio.connection.credentialId,
-      membershipCredential: portfolio.connection.membershipCredential,
-      providerAccessToken: portfolio.connection.providerAccessToken,
-      providerSessionId: portfolio.connection.providerSessionId,
-      providerSessionSequence: portfolio.connection.providerSessionSequence,
-      privateJwk: input.privateJwk,
-      assignmentId: null,
-      expectedAssignmentCount: 2,
-      maxConcurrentRunners: 2,
-      executionProviderId: "codex",
-      capabilities: portfolio.capabilities
-    });
-    const assignmentIds = execution.assignmentIds ?? [execution.assignmentId];
-    if (assignmentIds.length !== 2) throw new Error(`Concurrent provider execution returned ${assignmentIds.length} assignments instead of two.`);
-    const assignments = await Promise.all(assignmentIds.map(async (assignmentId) => (await input.adminClient.capacityProviderAssignment(input.runtime.teamId, assignmentId)).payload));
-    const expectedProjects = /* @__PURE__ */ new Set([engineering.project.id, research.project.id]);
-    if (new Set(assignments.map((assignment) => String(assignment.projectId))).size !== 2 || assignments.some((assignment) => !expectedProjects.has(String(assignment.projectId)))) {
-      throw new Error(`Concurrent provider assignments crossed project scope: ${JSON.stringify(assignments.map((entry) => ({ id: entry.id, projectId: entry.projectId })))}`);
-    }
-    const terminals = await Promise.all(assignments.map((assignment) => verifyCapacityAcceptanceTerminal({
-      adminClient: input.adminClient,
-      config: { teamId: input.runtime.teamId, projectId: String(assignment.projectId) },
-      assignmentId: String(assignment.id),
-      minimumArtifactCount: 1
-    })));
-    const starts = assignments.map((assignment) => timestamp(assignment.claimedAt ?? assignment.assignedAt));
-    const ends = assignments.map((assignment) => timestamp(assignment.completedAt ?? assignment.updatedAt));
-    const overlapMs = Math.min(...ends) - Math.max(...starts);
-    if (starts.some((value) => value === 0) || ends.some((value) => value === 0) || overlapMs <= 0) {
-      throw new Error(`Concurrent assignments did not retain overlapping durable lease intervals: ${JSON.stringify({ starts, ends, overlapMs })}`);
-    }
-    const workspaceIds = assignments.map(workspaceId);
-    if (workspaceIds.some((id) => !id) || new Set(workspaceIds).size !== 2) throw new Error("Concurrent assignments did not retain independent TreeDX workspaces.");
-    if (!hasConcurrentUsageAndExactlyOnceSettlement(terminals)) {
-      throw new Error(`Concurrent assignments did not retain usage evidence and exactly one ledger settlement per project: ${JSON.stringify(terminals)}`);
-    }
-    return {
-      projectIds: [...expectedProjects],
-      assignmentIds,
-      workspaceIds,
-      overlapMs,
-      usageActualCount: terminals.reduce((total, terminal) => total + terminal.usageActualCount, 0),
-      ledgerEntryCount: terminals.reduce((total, terminal) => total + terminal.ledgerEntryCount, 0),
-      artifactCount: terminals.reduce((total, terminal) => total + terminal.artifactCount, 0)
-    };
-  } catch (error) {
-    executionError = error;
-    throw error;
-  } finally {
-    await finalizeLocalStarterAcceptance(portfolio.cleanup, executionError, "Concurrent starter");
-  }
-}
-export {
-  concurrentProjectClassTransitionKey,
-  hasConcurrentUsageAndExactlyOnceSettlement,
-  runLocalConcurrentStarterAcceptance
-};

package/dist/reconcile/support/acceptance/live-acceptance-starter-engineering.d.ts

@@ -1,18 +0,0 @@
-import { MarketClient } from '../../../entrypoints/clients/market-client.js';
-import type { CapacityAcceptanceProof } from '../../capacity/capacity-core/live-acceptance-capacity-context.js';
-import type { CapacityAcceptanceExecutionInput } from '../../capacity/capacity-core/live-acceptance-capacity-executor.js';
-import type { CapacityGovernanceRuntimeConnection } from '../../capacity/capacity-core/live-acceptance-capacity-governance.js';
-import { type LocalStarterCapacityConfig } from '../../runtime/live-acceptance-starter-runtime.js';
-import type { RunLiveReconcileTestsOptions } from './live-acceptance.js';
-export declare const ENGINEERING_STARTER_CAPABILITIES: string[];
-export declare function engineeringStarterCapacityConfig(runId: string, exactBaseRef: string): LocalStarterCapacityConfig;
-export declare function createdEngineeringProposalId(assignment: Record<string, unknown>): string | null;
-export declare function runLocalEngineeringStarterAcceptance(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    fetchImpl: typeof fetch;
-    privateJwk: CapacityAcceptanceExecutionInput['privateJwk'];
-    executor: NonNullable<RunLiveReconcileTestsOptions['capacityAssignmentExecutor']>;
-}): Promise<NonNullable<CapacityAcceptanceProof['starterEngineering']>>;

package/dist/reconcile/support/acceptance/live-acceptance-starter-engineering.js

@@ -1,264 +0,0 @@
-import { resolve } from "node:path";
-import { runGitText } from "../../../operations/services/operations/git-runner.js";
-import { verifyCapacityAcceptanceTerminal } from "../../capacity/capacity-core/live-acceptance-capacity-terminal.js";
-import { finalizeLocalStarterAcceptance, provisionLocalStarterCapacity } from "../../runtime/live-acceptance-starter-runtime.js";
-const AGENTS = ["architect", "engineer", "releaser", "reporter", "researcher", "reviewer", "technical-writer", "tester"].map((slug) => `template/src/content/agents/${slug}.mdx`);
-const ENGINEERING_STARTER_CAPABILITIES = [
-  "planning",
-  "repo_read",
-  "repo_write",
-  "agent_mode_run",
-  "usage_report",
-  "architecture",
-  "engineering",
-  "release",
-  "reporting",
-  "research",
-  "review",
-  "technical-writing",
-  "testing",
-  "engineering:research",
-  "engineering:architecture",
-  "engineering:test",
-  "engineering:implementation",
-  "engineering:verification",
-  "engineering:review",
-  "engineering:documentation",
-  "engineering:release"
-];
-const DECISION_ID = "normalize-release-channel-inputs";
-const OBJECTIVE_ID = "ship-the-first-guided-change";
-function engineeringStarterCapacityConfig(runId, exactBaseRef) {
-  return {
-    starter: "engineering",
-    repositoryName: "treeseed-starter-engineering",
-    agentPaths: AGENTS,
-    capabilities: ENGINEERING_STARTER_CAPABILITIES,
-    allowedModes: ["planning", "acting"],
-    agentSeconds: 3600,
-    parameters: ({ projectId }) => ({
-      engineeringWorkflows: [{
-        schemaVersion: 1,
-        id: `engineering-workflow:${runId}`,
-        projectId,
-        decisionId: DECISION_ID,
-        objectiveId: OBJECTIVE_ID,
-        exactBaseRef,
-        roles: { tester: "testing", engineer: "engineering", reviewer: "review", technicalWriter: "technical-writing", releaser: "release", researcher: "research", architect: "architecture" },
-        includeResearch: true,
-        includeArchitecture: true,
-        requireLinkedProposal: true,
-        requireRevisionCycle: true,
-        metadata: { liveAcceptance: true }
-      }]
-    }),
-    projectMetadata: {
-      architecture: { topology: "single_repository_site", rootPath: "template", sitePath: "template", contentPath: "template/src/content", contentRuntimeSource: "treedx_snapshot", localContentMaterialization: "existing_path" },
-      repository: { provider: "git", owner: "treeseed-ai", name: "template-engineering", defaultBranch: "main", checkoutPath: "starters/engineering", cloneUrl: "https://github.com/treeseed-ai/template-engineering.git" },
-      agentSpecs: { root: "template/src/content/agents", testsRoot: "template/src/content/agent-tests" }
-    }
-  };
-}
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function graphNodes(graph) {
-  return Array.isArray(graph.nodes) ? graph.nodes.map(record) : [];
-}
-function createdEngineeringProposalId(assignment) {
-  const lifecycleOutput = record(assignment.lifecycleOutput);
-  const artifactManifest = record(lifecycleOutput.artifactManifest);
-  const references = Array.isArray(artifactManifest.contentReferences) ? artifactManifest.contentReferences.map(record) : [];
-  const proposal = references.find((reference) => reference.model === "proposal");
-  const path = typeof proposal?.contentPath === "string" ? proposal.contentPath : "";
-  const match = path.match(/\/proposals\/([^/]+)\.mdx?$/u);
-  return match?.[1] ?? null;
-}
-async function runLocalEngineeringStarterAcceptance(input) {
-  const repositoryRoot = resolve(process.cwd(), "starters/engineering");
-  const exactBaseRef = runGitText(["rev-parse", "HEAD"], { cwd: repositoryRoot, mode: "read" }).trim();
-  if (!/^[a-f0-9]{40}$/u.test(exactBaseRef)) throw new Error("Engineering starter acceptance could not resolve an exact source commit.");
-  const starter = await provisionLocalStarterCapacity({
-    ...input,
-    config: engineeringStarterCapacityConfig(input.runId, exactBaseRef)
-  });
-  let sequence = starter.connection.providerSessionSequence;
-  let completedAssignments = 0;
-  let artifactCount = 0;
-  let usageActualCount = 0;
-  let ledgerEntryCount = 0;
-  const agents = /* @__PURE__ */ new Set();
-  const setClassState = async (classSlug, body, transition) => {
-    const classId = `${starter.project.id}:${classSlug}`;
-    return input.adminClient.updateProjectAgentClass(
-      starter.project.id,
-      classId,
-      body,
-      `engineering-starter:${input.runId}:${transition}:${classSlug}`
-    );
-  };
-  const executeNext = async (label, expectedArtifacts) => {
-    await input.adminClient.tickWorkdayRun(starter.connection.teamId, starter.workdayRunId, {
-      idempotencyKey: `engineering-starter:${input.runId}:tick:${label}`
-    });
-    const execution = await input.executor({
-      runId: `${input.runId}-engineering-${label}`,
-      apiUrl: input.apiUrl,
-      repositoryRoot,
-      teamId: starter.connection.teamId,
-      projectId: starter.project.id,
-      providerId: starter.connection.providerId,
-      membershipId: starter.connection.membershipId,
-      credentialId: starter.connection.credentialId,
-      membershipCredential: starter.connection.membershipCredential,
-      providerAccessToken: starter.connection.providerAccessToken,
-      providerSessionId: starter.connection.providerSessionId,
-      providerSessionSequence: sequence,
-      privateJwk: input.privateJwk,
-      assignmentId: null,
-      executionProviderId: "codex",
-      capabilities: ENGINEERING_STARTER_CAPABILITIES,
-      activityProfile: { kind: "engineering-workflow", subjectModel: "objective", subjectSlug: OBJECTIVE_ID }
-    });
-    sequence = Number(execution.providerSessionSequence ?? sequence);
-    const assignment = await input.adminClient.capacityProviderAssignment(starter.connection.teamId, execution.assignmentId);
-    const terminal = await verifyCapacityAcceptanceTerminal({
-      adminClient: input.adminClient,
-      config: { teamId: starter.connection.teamId, projectId: starter.project.id },
-      assignmentId: execution.assignmentId,
-      minimumArtifactCount: expectedArtifacts ?? (assignment.payload.handlerId === "estimate" ? 0 : 1)
-    });
-    agents.add(String(assignment.payload.agentId ?? ""));
-    completedAssignments += 1;
-    artifactCount += terminal.artifactCount;
-    usageActualCount += terminal.usageActualCount;
-    ledgerEntryCount += terminal.ledgerEntryCount;
-    return assignment.payload;
-  };
-  let executionError;
-  try {
-    for (const classSlug of ["engineering", "release", "reporting", "research", "review", "technical-writing", "testing"]) {
-      await setClassState(classSlug, { status: "paused" }, "proposal-profile");
-    }
-    await setClassState("architecture", { status: "active", allowedModes: ["planning"] }, "proposal-profile");
-    await input.adminClient.createPlanningInputRequest(DECISION_ID, {
-      id: `engineering-proposal:${input.runId}`,
-      projectId: starter.project.id,
-      projectAgentClassId: `${starter.project.id}:architecture`,
-      mode: "planning",
-      prompt: "Create the linked test-first release-channel proposal.",
-      metadata: { agentId: "architect", objectiveId: OBJECTIVE_ID, planningSource: "engineering-live-proposal", priority: 100 }
-    });
-    const proposalAssignment = await executeNext("proposal", 1);
-    const proposalId = createdEngineeringProposalId(proposalAssignment);
-    if (!proposalId) throw new Error(`Engineering starter proposal assignment omitted its created proposal reference: ${JSON.stringify(proposalAssignment.lifecycleOutput ?? null)}`);
-    const engineeringClassId = `${starter.project.id}:engineering`;
-    const engineeringClass = (await input.adminClient.projectAgentClass(starter.project.id, engineeringClassId)).payload;
-    const handlerRefs = structuredClone(record(engineeringClass.handlerRefs));
-    const classAgents = Array.isArray(handlerRefs.agents) ? handlerRefs.agents.map(record) : [];
-    for (const agent of classAgents) {
-      const activities = record(agent.activities);
-      delete activities.planning;
-      delete activities.reviewing;
-      delete activities.reporting;
-      agent.activities = activities;
-    }
-    handlerRefs.agents = classAgents;
-    await setClassState("architecture", { status: "paused" }, "estimate-profile");
-    const estimateProfile = await setClassState("engineering", { status: "active", handlerRefs, allowedModes: ["planning", "acting"] }, "estimate-profile");
-    const returnedRefs = record(record(estimateProfile.payload).handlerRefs);
-    const returnedAgents = Array.isArray(returnedRefs.agents) ? returnedRefs.agents.map(record) : [];
-    const estimateActivities = record(returnedAgents[0]?.activities);
-    if (!estimateActivities.estimating || estimateActivities.planning || estimateActivities.reviewing) {
-      throw new Error(`Engineering estimate profile did not become canonical: ${JSON.stringify(estimateProfile.payload)}`);
-    }
-    await input.adminClient.createPlanningInputRequest(DECISION_ID, {
-      id: `engineering-estimate:${input.runId}`,
-      projectId: starter.project.id,
-      projectAgentClassId: `${starter.project.id}:engineering`,
-      mode: "planning",
-      prompt: "Estimate the accepted release-channel proposal.",
-      metadata: { agentId: "engineer", objectiveId: OBJECTIVE_ID, planningSource: "engineering-live-estimate", priority: 100, activityType: "estimating" }
-    });
-    let estimate;
-    for (let index = 0; index < 12 && !estimate; index += 1) {
-      await executeNext(`estimate-${index}`);
-      const estimates = await input.adminClient.decisionStructuredEstimates(DECISION_ID, "submitted");
-      estimate = estimates.payload.find((entry) => entry.projectId === starter.project.id);
-    }
-    if (!estimate?.id || estimate.decisionId !== DECISION_ID || estimate.proposalId !== proposalId) {
-      throw new Error(`Engineering starter did not produce its linked estimate: ${JSON.stringify(estimate)}`);
-    }
-    await input.adminClient.acceptStructuredAgentEstimate(String(estimate.id), { metadata: { liveAcceptance: true } });
-    for (const classSlug of ["architecture", "engineering", "release", "research", "review", "technical-writing", "testing"]) {
-      await setClassState(classSlug, { status: "active", allowedModes: ["acting"] }, "acting-profile");
-    }
-    await setClassState("reporting", { status: "paused", allowedModes: ["planning"] }, "acting-profile");
-    let graph = null;
-    for (let index = 0; index < 20; index += 1) {
-      const graphs = await input.adminClient.decisionAssignmentGraphs(DECISION_ID, { active: true });
-      graph = graphs.payload.find((entry) => entry.projectId === starter.project.id) ?? null;
-      if (graph?.status === "completed") break;
-      await executeNext(`graph-${index}`);
-    }
-    if (!graph || graph.status !== "completed") throw new Error(`Engineering starter graph did not complete: ${JSON.stringify(graph)}`);
-    const nodes = graphNodes(graph);
-    const stages = new Set(nodes.map((node) => String(record(node.metadata).stage ?? "")));
-    const revisionNodes = nodes.filter((node) => Number(record(node.metadata).revisionCycle ?? 0) > 0);
-    for (const stage of ["research", "architecture", "test", "implementation", "verification", "review", "documentation", "release"]) {
-      if (!stages.has(stage)) throw new Error(`Engineering starter graph omitted ${stage}.`);
-    }
-    if (revisionNodes.length !== 3 || !nodes.every((node) => node.status === "completed")) throw new Error("Engineering starter graph omitted its complete three-node revision cycle.");
-    const reportingClassId = `${starter.project.id}:reporting`;
-    const reportingClass = (await input.adminClient.projectAgentClass(starter.project.id, reportingClassId)).payload;
-    const reportingRefs = structuredClone(record(reportingClass.handlerRefs));
-    const reportingAgents = Array.isArray(reportingRefs.agents) ? reportingRefs.agents.map(record) : [];
-    for (const agent of reportingAgents) {
-      const activities = record(agent.activities);
-      for (const activityType of Object.keys(activities)) if (activityType !== "reporting") delete activities[activityType];
-      agent.activities = activities;
-    }
-    reportingRefs.agents = reportingAgents;
-    await setClassState("reporting", { status: "active", allowedModes: ["planning"], handlerRefs: reportingRefs }, "reporting-profile");
-    await input.adminClient.createPlanningInputRequest(DECISION_ID, {
-      id: `engineering-report:${input.runId}`,
-      projectId: starter.project.id,
-      projectAgentClassId: `${starter.project.id}:reporting`,
-      mode: "planning",
-      prompt: "Produce the canonical engineering workday summary.",
-      metadata: { agentId: "reporter", objectiveId: OBJECTIVE_ID, planningSource: "engineering-live-report", priority: 100, activityType: "reporting" }
-    });
-    let report = null;
-    for (let index = 0; index < 12 && report?.agentId !== "reporter"; index += 1) {
-      report = await executeNext(`report-${index}`);
-    }
-    if (!agents.has("tester") || !agents.has("engineer") || !agents.has("reviewer") || !agents.has("technical-writer") || !agents.has("releaser") || report.agentId !== "reporter") {
-      throw new Error(`Engineering starter omitted required role execution: ${JSON.stringify([...agents])}`);
-    }
-    return {
-      starter: "engineering",
-      projectId: starter.project.id,
-      assignmentId: String(report.id),
-      completedAssignments,
-      artifactCount,
-      usageActualCount,
-      ledgerEntryCount,
-      graphStatus: String(graph.status),
-      graphNodeCount: nodes.length,
-      revisionNodeCount: revisionNodes.length,
-      exactBaseRef,
-      participatingAgents: [...agents].filter(Boolean).sort()
-    };
-  } catch (error) {
-    executionError = error;
-    throw error;
-  } finally {
-    await finalizeLocalStarterAcceptance(starter.cleanup, executionError, "Engineering starter");
-  }
-}
-export {
-  ENGINEERING_STARTER_CAPABILITIES,
-  createdEngineeringProposalId,
-  engineeringStarterCapacityConfig,
-  runLocalEngineeringStarterAcceptance
-};