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

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
-};

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

@@ -1,44 +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 RESEARCH_STARTER_CAPABILITIES: string[];
-export declare function researchStarterCapacityConfig(): LocalStarterCapacityConfig;
-export declare function provisionLocalResearchStarterPlanning(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    privateJwk: CapacityAcceptanceExecutionInput['privateJwk'];
-    fetchImpl: typeof fetch;
-}): Promise<{
-    project: {
-        id: string;
-        slug: string;
-    };
-    workflowId: string;
-    runId: string;
-    connection: {
-        providerAccessToken: string;
-        projectId: string;
-        providerSessionId: string;
-        providerSessionSequence: number;
-        teamId: string;
-        providerId: string;
-        membershipId: string;
-        credentialId: string;
-        membershipCredential: string;
-    };
-    cleanup: (runStatus?: "completed" | "cancelled") => Promise<void>;
-}>;
-export declare function runLocalResearchStarterPlanningAcceptance(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    fetchImpl: typeof fetch;
-    privateJwk: CapacityAcceptanceExecutionInput['privateJwk'];
-    executor: NonNullable<RunLiveReconcileTestsOptions['capacityAssignmentExecutor']>;
-}): Promise<NonNullable<CapacityAcceptanceProof['starterPlanning']>>;

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

@@ -1,154 +0,0 @@
-import { verifyCapacityAcceptanceTerminal } from "../../capacity/capacity-core/live-acceptance-capacity-terminal.js";
-import { finalizeLocalStarterAcceptance, provisionLocalStarterCapacity } from "../../runtime/live-acceptance-starter-runtime.js";
-const RESEARCH_AGENT_PATHS = ["researcher", "reviewer", "technical-writer", "reporter"].map((slug) => `template/src/content/agents/${slug}.mdx`);
-const ROLE_CLASSES = { researcher: "research", reviewer: "review", "technical-writer": "technical-writing", reporter: "reporting" };
-const RESEARCH_STARTER_CAPABILITIES = ["planning", "repo_read", "agent_mode_run", "usage_report", "research", "review", "technical-writing", "reporting"];
-function researchStarterCapacityConfig() {
-  return {
-    starter: "research",
-    repositoryName: "treeseed-starter-research",
-    agentPaths: RESEARCH_AGENT_PATHS,
-    capabilities: RESEARCH_STARTER_CAPABILITIES,
-    allowedModes: ["planning"],
-    agentSeconds: 3600,
-    durationSeconds: 14400,
-    parameters: { planningOnly: true, metadata: { liveAcceptance: true, starter: "research" } },
-    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-research", defaultBranch: "main", checkoutPath: "starters/research", cloneUrl: "https://github.com/treeseed-ai/template-research.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 : {};
-}
-async function provisionLocalResearchStarterPlanning(input) {
-  const key = `research-starter:${input.runId}`;
-  const starter = await provisionLocalStarterCapacity({
-    ...input,
-    config: researchStarterCapacityConfig()
-  });
-  try {
-    const workflowId = `${key}:workflow`;
-    await input.adminClient.createResearchWorkflow(starter.project.id, {
-      id: workflowId,
-      objectiveRef: "objective:publish-the-first-knowledge-pack",
-      questionRef: "question:what-should-this-research-map-first",
-      minimumIndependentSources: 2,
-      maxRevisionCycles: 3,
-      idempotencyKey: `${key}:workflow-create`,
-      metadata: { liveAcceptance: true, runId: input.runId }
-    });
-    return {
-      project: starter.project,
-      workflowId,
-      runId: starter.workdayRunId,
-      connection: starter.connection,
-      cleanup: starter.cleanup
-    };
-  } catch (error) {
-    await starter.cleanup("cancelled").catch((cleanupError) => {
-      throw new AggregateError([error, cleanupError], "Research starter provisioning and cleanup both failed.");
-    });
-    throw error;
-  }
-}
-async function runLocalResearchStarterPlanningAcceptance(input) {
-  const starter = await provisionLocalResearchStarterPlanning(input);
-  let executionError;
-  try {
-    let sequence = starter.connection.providerSessionSequence;
-    let assignmentId = "";
-    let artifactCount = 0;
-    let usageActualCount = 0;
-    let ledgerEntryCount = 0;
-    let completedAssignments = 0;
-    let workflow = (await input.adminClient.researchWorkflow(starter.workflowId)).payload;
-    let activeRole = "";
-    for (let index = 0; index < 64 && workflow.status !== "completed"; index += 1) {
-      const readyNode = Array.isArray(workflow.nodes) ? workflow.nodes.map(record).find((node) => node.status === "ready") : null;
-      const requiredRole = String(readyNode?.role ?? "");
-      if (!(requiredRole in ROLE_CLASSES)) throw new Error(`Research starter workflow has no configured role for its ready node: ${JSON.stringify(readyNode)}`);
-      if (requiredRole !== activeRole) {
-        await Promise.all(Object.entries(ROLE_CLASSES).map(([role, classSlug]) => input.adminClient.updateProjectAgentClass(
-          starter.project.id,
-          `${starter.project.id}:${classSlug}`,
-          { status: role === requiredRole ? "active" : "paused", allowedModes: ["planning"] },
-          `research-starter:${input.runId}:stage-role:${index}:${role}`
-        )));
-        activeRole = requiredRole;
-      }
-      await input.adminClient.tickWorkdayRun(starter.connection.teamId, starter.runId, {
-        idempotencyKey: `research-starter:${input.runId}:tick:${index}`
-      });
-      const execution = await input.executor({
-        runId: `${input.runId}-research-${index}`,
-        apiUrl: input.apiUrl,
-        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: RESEARCH_STARTER_CAPABILITIES,
-        activityProfile: { kind: "research-workflow", subjectModel: "question", subjectSlug: "what-should-this-research-map-first" }
-      });
-      sequence = Number(execution.providerSessionSequence ?? sequence);
-      assignmentId = execution.assignmentId;
-      const completedAssignment = await input.adminClient.capacityProviderAssignment(starter.connection.teamId, assignmentId);
-      const researchStage = String(record(record(completedAssignment.payload.decisionInput).input).researchStage ?? "");
-      const terminal = await verifyCapacityAcceptanceTerminal({
-        adminClient: input.adminClient,
-        config: { teamId: starter.connection.teamId, projectId: starter.project.id },
-        assignmentId,
-        minimumArtifactCount: researchStage === "linked-evidence-notes" ? 2 : 1
-      });
-      artifactCount += terminal.artifactCount;
-      usageActualCount += terminal.usageActualCount;
-      ledgerEntryCount += terminal.ledgerEntryCount;
-      completedAssignments += 1;
-      workflow = (await input.adminClient.researchWorkflow(starter.workflowId)).payload;
-    }
-    if (workflow.status !== "completed" || workflow.reviewerRejectedUnsupportedClaims !== true || workflow.reviewerApprovedRevision !== true) {
-      throw new Error(`Research starter workflow did not complete its rejection/revision/approval graph: ${JSON.stringify(workflow)}`);
-    }
-    if (!Array.isArray(workflow.citations) || workflow.citations.length < 2 || Number(workflow.revisionCount) < 1) {
-      throw new Error("Research starter workflow omitted independent citations or its required revision.");
-    }
-    const assignment = await input.adminClient.capacityProviderAssignment(starter.connection.teamId, assignmentId);
-    const proof = {
-      starter: "research",
-      projectId: starter.project.id,
-      assignmentId,
-      agentId: String(assignment.payload.agentId ?? ""),
-      handlerId: String(assignment.payload.handlerId ?? ""),
-      artifactCount,
-      usageActualCount,
-      ledgerEntryCount,
-      completedAssignments,
-      workflowStatus: String(workflow.status),
-      citationCount: workflow.citations.length,
-      revisionCount: Number(workflow.revisionCount)
-    };
-    if (!proof.agentId || !proof.handlerId) throw new Error("Research starter planning assignment omitted its content-defined agent or handler identity.");
-    return proof;
-  } catch (error) {
-    executionError = error;
-    throw error;
-  } finally {
-    await finalizeLocalStarterAcceptance(starter.cleanup, executionError, "Research starter");
-  }
-}
-export {
-  RESEARCH_STARTER_CAPABILITIES,
-  provisionLocalResearchStarterPlanning,
-  researchStarterCapacityConfig,
-  runLocalResearchStarterPlanningAcceptance
-};

package/dist/reconcile/support/acceptance/live-acceptance-starters.d.ts

@@ -1,51 +0,0 @@
-import { MarketClient } from '../../../entrypoints/clients/market-client.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 runLocalAutonomousStarterAcceptances(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    fetchImpl: typeof fetch;
-    privateJwk: CapacityAcceptanceExecutionInput['privateJwk'];
-    executor: NonNullable<RunLiveReconcileTestsOptions['capacityAssignmentExecutor']>;
-}): Promise<{
-    starterPlanning: {
-        starter: "research";
-        projectId: string;
-        assignmentId: string;
-        agentId: string;
-        handlerId: string;
-        artifactCount: number;
-        usageActualCount: number;
-        ledgerEntryCount: number;
-        completedAssignments?: number;
-        workflowStatus?: string;
-        citationCount?: number;
-        revisionCount?: number;
-    };
-    starterEngineering: {
-        starter: "engineering";
-        projectId: string;
-        assignmentId: string;
-        completedAssignments: number;
-        artifactCount: number;
-        usageActualCount: number;
-        ledgerEntryCount: number;
-        graphStatus: string;
-        graphNodeCount: number;
-        revisionNodeCount: number;
-        exactBaseRef: string;
-        participatingAgents: string[];
-    };
-    starterConcurrency: {
-        projectIds: string[];
-        assignmentIds: string[];
-        workspaceIds: string[];
-        overlapMs: number;
-        artifactCount: number;
-        usageActualCount: number;
-        ledgerEntryCount: number;
-    };
-}>;

package/dist/reconcile/support/acceptance/live-acceptance-starters.js

@@ -1,12 +0,0 @@
-import { runLocalConcurrentStarterAcceptance } from "./live-acceptance-starter-concurrency.js";
-import { runLocalEngineeringStarterAcceptance } from "./live-acceptance-starter-engineering.js";
-import { runLocalResearchStarterPlanningAcceptance } from "./live-acceptance-starter-planning.js";
-async function runLocalAutonomousStarterAcceptances(input) {
-  const starterConcurrency = await runLocalConcurrentStarterAcceptance(input);
-  const starterEngineering = await runLocalEngineeringStarterAcceptance(input);
-  const starterPlanning = await runLocalResearchStarterPlanningAcceptance(input);
-  return { starterPlanning, starterEngineering, starterConcurrency };
-}
-export {
-  runLocalAutonomousStarterAcceptances
-};

package/dist/reconcile/support/acceptance/live-acceptance-values.d.ts

@@ -1,2 +0,0 @@
-export type LiveAcceptanceEnv = NodeJS.ProcessEnv | Record<string, string | undefined>;
-export declare function configuredLiveAcceptanceValue(env: LiveAcceptanceEnv, keys: string[]): string;

package/dist/reconcile/support/acceptance/live-acceptance-values.js

@@ -1,10 +0,0 @@
-function configuredLiveAcceptanceValue(env, keys) {
-  for (const key of keys) {
-    const value = env[key];
-    if (typeof value === "string" && value.trim()) return value.trim();
-  }
-  return "";
-}
-export {
-  configuredLiveAcceptanceValue
-};

package/dist/reconcile/support/acceptance/live-acceptance-worktree-cleanup.d.ts

@@ -1,7 +0,0 @@
-export declare function cleanupLocalAcceptanceAgentWorktrees(workspaceRoot: string): Promise<{
-    removed: {
-        repoRoot: string;
-        worktreeRoot: string;
-    }[];
-    failures: string[];
-}>;

package/dist/reconcile/support/acceptance/live-acceptance-worktree-cleanup.js

@@ -1,38 +0,0 @@
-import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
-import { isAbsolute, relative, resolve } from "node:path";
-import { promisify } from "node:util";
-import { releaseAgentWorktree } from "../../../operations/packages/agent-worktree-release.js";
-const execFileAsync = promisify(execFile);
-function registeredWorktrees(porcelain) {
-  return porcelain.split(/\r?\n/gu).filter((line) => line.startsWith("worktree ")).map((line) => resolve(line.slice("worktree ".length).trim()));
-}
-function descendsFrom(root, candidate) {
-  const child = relative(root, candidate);
-  return child !== "" && !child.startsWith("..") && !isAbsolute(child);
-}
-async function cleanupLocalAcceptanceAgentWorktrees(workspaceRoot) {
-  const removed = [];
-  const failures = [];
-  for (const relativeRepo of ["starters/engineering", "starters/research"]) {
-    const repoRoot = resolve(workspaceRoot, relativeRepo);
-    const assignmentRoot = resolve(repoRoot, ".agent-worktrees");
-    if (!existsSync(repoRoot)) continue;
-    try {
-      const listed = await execFileAsync("git", ["worktree", "list", "--porcelain"], {
-        cwd: repoRoot,
-        env: process.env
-      });
-      for (const worktreeRoot of registeredWorktrees(listed.stdout).filter((path) => descendsFrom(assignmentRoot, path))) {
-        const result = await releaseAgentWorktree({ repoRoot, worktreeRoot });
-        if (result.removed) removed.push({ repoRoot, worktreeRoot });
-      }
-    } catch (error) {
-      failures.push(`${relativeRepo}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  return { removed, failures };
-}
-export {
-  cleanupLocalAcceptanceAgentWorktrees
-};