@treeseed/core 0.8.3 → 0.8.5

package/dist/agents/contracts/messages.d.ts

@@ -1,88 +0,0 @@
-export interface QuestionPriorityUpdatedMessage {
-    questionId: string;
-    reason: string;
-    plannerRunId: string;
-}
-export interface ObjectivePriorityUpdatedMessage {
-    objectiveId: string;
-    reason: string;
-    plannerRunId: string;
-}
-export interface ArchitectureUpdatedMessage {
-    objectiveId: string;
-    knowledgeId: string;
-    architectRunId: string;
-}
-export interface SubscriberNotifiedMessage {
-    email: string;
-    itemCount: number;
-    notifierRunId: string;
-}
-export interface ResearchStartedMessage {
-    questionId: string;
-    researcherRunId: string;
-}
-export interface ResearchCompletedMessage {
-    questionId: string;
-    knowledgeId: string | null;
-    researcherRunId: string;
-}
-export interface TaskCompleteMessage {
-    branchName: string | null;
-    changedTargets: string[];
-    engineerRunId: string;
-}
-export interface TaskWaitingMessage {
-    blockingReason: string;
-    engineerRunId: string;
-}
-export interface TaskFailedMessage {
-    failureSummary: string;
-    engineerRunId: string;
-}
-export interface TaskVerifiedMessage {
-    branchName: string | null;
-    reviewerRunId: string;
-}
-export interface ReviewFailedMessage {
-    failureSummary: string;
-    reviewerRunId: string;
-}
-export interface ReviewWaitingMessage {
-    blockingReason: string;
-    reviewerRunId: string;
-}
-export interface ReleaseStartedMessage {
-    taskRunId: string | null;
-    releaserRunId: string;
-}
-export interface ReleaseCompletedMessage {
-    releaseSummary: string;
-    releaserRunId: string;
-}
-export interface ReleaseFailedMessage {
-    failureSummary: string;
-    releaserRunId: string;
-}
-export interface AgentMessageContracts {
-    question_priority_updated: QuestionPriorityUpdatedMessage;
-    objective_priority_updated: ObjectivePriorityUpdatedMessage;
-    architecture_updated: ArchitectureUpdatedMessage;
-    subscriber_notified: SubscriberNotifiedMessage;
-    research_started: ResearchStartedMessage;
-    research_completed: ResearchCompletedMessage;
-    task_complete: TaskCompleteMessage;
-    task_waiting: TaskWaitingMessage;
-    task_failed: TaskFailedMessage;
-    task_verified: TaskVerifiedMessage;
-    review_failed: ReviewFailedMessage;
-    review_waiting: ReviewWaitingMessage;
-    release_started: ReleaseStartedMessage;
-    release_completed: ReleaseCompletedMessage;
-    release_failed: ReleaseFailedMessage;
-}
-export type AgentMessageType = keyof AgentMessageContracts;
-export type AgentMessagePayload<TType extends AgentMessageType> = AgentMessageContracts[TType];
-export declare const AGENT_MESSAGE_TYPES: readonly ["question_priority_updated", "objective_priority_updated", "architecture_updated", "subscriber_notified", "research_started", "research_completed", "task_complete", "task_waiting", "task_failed", "task_verified", "review_failed", "review_waiting", "release_started", "release_completed", "release_failed"];
-export declare function parseAgentMessagePayload<TType extends AgentMessageType>(type: TType, payloadJson: string): AgentMessagePayload<TType>;
-export declare function serializeAgentMessagePayload<TType extends AgentMessageType>(type: TType, payload: AgentMessagePayload<TType>): Record<string, unknown>;

package/dist/agents/contracts/messages.js

@@ -1,138 +0,0 @@
-const AGENT_MESSAGE_TYPES = [
-  "question_priority_updated",
-  "objective_priority_updated",
-  "architecture_updated",
-  "subscriber_notified",
-  "research_started",
-  "research_completed",
-  "task_complete",
-  "task_waiting",
-  "task_failed",
-  "task_verified",
-  "review_failed",
-  "review_waiting",
-  "release_started",
-  "release_completed",
-  "release_failed"
-];
-function ensureString(value, label) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`Invalid ${label}: expected non-empty string.`);
-  }
-  return value;
-}
-function ensureOptionalString(value, label) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  return ensureString(value, label);
-}
-function ensureStringArray(value, label) {
-  if (!Array.isArray(value)) {
-    throw new Error(`Invalid ${label}: expected array.`);
-  }
-  return value.map((entry, index) => ensureString(entry, `${label}[${index}]`));
-}
-function ensureNumber(value, label) {
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    throw new Error(`Invalid ${label}: expected number.`);
-  }
-  return value;
-}
-function parseAgentMessagePayload(type, payloadJson) {
-  const parsed = JSON.parse(payloadJson);
-  switch (type) {
-    case "question_priority_updated":
-      return {
-        questionId: ensureString(parsed.questionId, "questionId"),
-        reason: ensureString(parsed.reason, "reason"),
-        plannerRunId: ensureString(parsed.plannerRunId, "plannerRunId")
-      };
-    case "objective_priority_updated":
-      return {
-        objectiveId: ensureString(parsed.objectiveId, "objectiveId"),
-        reason: ensureString(parsed.reason, "reason"),
-        plannerRunId: ensureString(parsed.plannerRunId, "plannerRunId")
-      };
-    case "architecture_updated":
-      return {
-        objectiveId: ensureString(parsed.objectiveId, "objectiveId"),
-        knowledgeId: ensureString(parsed.knowledgeId, "knowledgeId"),
-        architectRunId: ensureString(parsed.architectRunId, "architectRunId")
-      };
-    case "subscriber_notified":
-      return {
-        email: ensureString(parsed.email, "email"),
-        itemCount: ensureNumber(parsed.itemCount, "itemCount"),
-        notifierRunId: ensureString(parsed.notifierRunId, "notifierRunId")
-      };
-    case "research_started":
-      return {
-        questionId: ensureString(parsed.questionId, "questionId"),
-        researcherRunId: ensureString(parsed.researcherRunId, "researcherRunId")
-      };
-    case "research_completed":
-      return {
-        questionId: ensureString(parsed.questionId, "questionId"),
-        knowledgeId: ensureOptionalString(parsed.knowledgeId, "knowledgeId"),
-        researcherRunId: ensureString(parsed.researcherRunId, "researcherRunId")
-      };
-    case "task_complete":
-      return {
-        branchName: ensureOptionalString(parsed.branchName, "branchName"),
-        changedTargets: ensureStringArray(parsed.changedTargets, "changedTargets"),
-        engineerRunId: ensureString(parsed.engineerRunId, "engineerRunId")
-      };
-    case "task_waiting":
-      return {
-        blockingReason: ensureString(parsed.blockingReason, "blockingReason"),
-        engineerRunId: ensureString(parsed.engineerRunId, "engineerRunId")
-      };
-    case "task_failed":
-      return {
-        failureSummary: ensureString(parsed.failureSummary, "failureSummary"),
-        engineerRunId: ensureString(parsed.engineerRunId, "engineerRunId")
-      };
-    case "task_verified":
-      return {
-        branchName: ensureOptionalString(parsed.branchName, "branchName"),
-        reviewerRunId: ensureString(parsed.reviewerRunId, "reviewerRunId")
-      };
-    case "review_failed":
-      return {
-        failureSummary: ensureString(parsed.failureSummary, "failureSummary"),
-        reviewerRunId: ensureString(parsed.reviewerRunId, "reviewerRunId")
-      };
-    case "review_waiting":
-      return {
-        blockingReason: ensureString(parsed.blockingReason, "blockingReason"),
-        reviewerRunId: ensureString(parsed.reviewerRunId, "reviewerRunId")
-      };
-    case "release_started":
-      return {
-        taskRunId: ensureOptionalString(parsed.taskRunId, "taskRunId"),
-        releaserRunId: ensureString(parsed.releaserRunId, "releaserRunId")
-      };
-    case "release_completed":
-      return {
-        releaseSummary: ensureString(parsed.releaseSummary, "releaseSummary"),
-        releaserRunId: ensureString(parsed.releaserRunId, "releaserRunId")
-      };
-    case "release_failed":
-      return {
-        failureSummary: ensureString(parsed.failureSummary, "failureSummary"),
-        releaserRunId: ensureString(parsed.releaserRunId, "releaserRunId")
-      };
-    default:
-      throw new Error(`Unsupported message type "${type}".`);
-  }
-}
-function serializeAgentMessagePayload(type, payload) {
-  parseAgentMessagePayload(type, JSON.stringify(payload));
-  return payload;
-}
-export {
-  AGENT_MESSAGE_TYPES,
-  parseAgentMessagePayload,
-  serializeAgentMessagePayload
-};

package/dist/agents/contracts/run.d.ts

@@ -1,21 +0,0 @@
-export type AgentErrorCategory = 'trigger_resolution_error' | 'permission_error' | 'message_claim_error' | 'lease_error' | 'execution_error' | 'mutation_error' | 'sdk_error';
-export interface AgentRunTrace {
-    [key: string]: unknown;
-    runId: string;
-    agentSlug: string;
-    handlerKind: string;
-    triggerKind: string;
-    triggerSource: string;
-    claimedMessageId: number | null;
-    selectedItemKey: string | null;
-    branchName: string | null;
-    commitSha: string | null;
-    changedPaths: string[];
-    summary: string | null;
-    error: string | null;
-    errorCategory: AgentErrorCategory | null;
-    startedAt: string;
-    finishedAt: string | null;
-    status: string;
-}
-export {};

package/dist/agents/index.d.ts

@@ -1 +0,0 @@
-export { listRegisteredAgentHandlers, resolveAgentHandler } from './registry.ts';

package/dist/agents/index.js

@@ -1,5 +0,0 @@
-import { listRegisteredAgentHandlers, resolveAgentHandler } from "./registry.js";
-export {
-  listRegisteredAgentHandlers,
-  resolveAgentHandler
-};

package/dist/agents/kernel/agent-kernel.d.ts

@@ -1,51 +0,0 @@
-import type { AgentExecutionAdapter, AgentMutationAdapter, AgentNotificationAdapter, AgentRepositoryInspectionAdapter, AgentResearchAdapter, AgentTriggerInvocation, AgentVerificationAdapter } from '../runtime-types.ts';
-import { AgentSdk } from '@treeseed/sdk/sdk';
-export declare class AgentKernel {
-    private readonly sdk;
-    private readonly repoRoot;
-    private readonly execution;
-    private readonly mutations;
-    private readonly repository;
-    private readonly verification;
-    private readonly notifications;
-    private readonly research;
-    private readonly activeRuns;
-    private readonly lastRunAt;
-    constructor(sdk: AgentSdk, repoRoot: string, options?: {
-        execution?: AgentExecutionAdapter;
-        mutations?: AgentMutationAdapter;
-        repository?: AgentRepositoryInspectionAdapter;
-        verification?: AgentVerificationAdapter;
-        notifications?: AgentNotificationAdapter;
-        research?: AgentResearchAdapter;
-    });
-    doctor(): Promise<{
-        agents: {
-            slug: string;
-            handler: string;
-            enabled: boolean;
-            triggers: ("startup" | "schedule" | "message" | "follow")[];
-        }[];
-        diagnostics: import("../spec-types.ts").AgentSpecDiagnostic[];
-    }>;
-    private sortAgents;
-    private resolveTrigger;
-    private recordRunTrace;
-    private buildTrace;
-    private categorizeError;
-    private executeAgent;
-    runAgent(slug: string, mode?: 'auto' | 'manual', invocation?: AgentTriggerInvocation | null): Promise<{
-        status: string;
-        summary: string;
-    }>;
-    runCycle(): Promise<any[]>;
-    start(intervalMs?: number): Promise<void>;
-    drainMessages(): Promise<any[]>;
-    releaseLeases(): Promise<import("@treeseed/sdk").SdkJsonEnvelope<{
-        count: number;
-    }>>;
-    replayMessage(id: number): Promise<{
-        id: number;
-        status: string;
-    }>;
-}

package/dist/agents/kernel/agent-kernel.js

@@ -1,292 +0,0 @@
-import { createExecutionAdapter } from "../adapters/execution.js";
-import { LocalBranchMutationAdapter } from "../adapters/mutations.js";
-import { createNotificationAdapter } from "../adapters/notification.js";
-import { createRepositoryInspectionAdapter } from "../adapters/repository.js";
-import { createResearchAdapter } from "../adapters/research.js";
-import { createVerificationAdapter } from "../adapters/verification.js";
-import { resolveAgentHandler } from "../registry.js";
-import { AgentSdk } from "@treeseed/sdk/sdk";
-import { followCursorKey, resolveTriggerDecision } from "./trigger-resolver.js";
-import { loadActiveAgentSpecs, loadAllAgentSpecs, summarizeAgentSpec } from "../spec-loader.js";
-import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
-import { resolveAgentRuntimeProviders } from "../../agent-runtime.js";
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-class AgentKernel {
-  constructor(sdk, repoRoot, options) {
-    this.sdk = sdk;
-    this.repoRoot = repoRoot;
-    const runtimeProviders = resolveAgentRuntimeProviders(repoRoot, getTreeseedAgentProviderSelections());
-    this.execution = options?.execution ?? runtimeProviders.execution ?? createExecutionAdapter();
-    this.mutations = options?.mutations ?? runtimeProviders.mutations ?? new LocalBranchMutationAdapter(repoRoot);
-    this.repository = options?.repository ?? runtimeProviders.repository ?? createRepositoryInspectionAdapter();
-    this.verification = options?.verification ?? runtimeProviders.verification ?? createVerificationAdapter();
-    this.notifications = options?.notifications ?? runtimeProviders.notifications ?? createNotificationAdapter();
-    this.research = options?.research ?? runtimeProviders.research ?? createResearchAdapter();
-  }
-  sdk;
-  repoRoot;
-  execution;
-  mutations;
-  repository;
-  verification;
-  notifications;
-  research;
-  activeRuns = /* @__PURE__ */ new Set();
-  lastRunAt = /* @__PURE__ */ new Map();
-  async doctor() {
-    const { specs, diagnostics } = await loadAllAgentSpecs(this.sdk);
-    for (const agent of specs.filter((entry) => entry.enabled)) {
-      await resolveAgentHandler(agent.handler);
-    }
-    const errors = diagnostics.filter((entry) => entry.severity === "error");
-    if (errors.length) {
-      throw new Error(
-        `Agent spec validation failed: ${errors.map((entry) => `${entry.slug}:${entry.field}:${entry.message}`).join(" | ")}`
-      );
-    }
-    return {
-      agents: specs.map(summarizeAgentSpec),
-      diagnostics
-    };
-  }
-  sortAgents(agents) {
-    const priority = {
-      planner: 10,
-      researcher: 20,
-      architect: 30,
-      engineer: 40,
-      reviewer: 50,
-      releaser: 60,
-      notifier: 70
-    };
-    return [...agents].sort(
-      (left, right) => (priority[left.handler] ?? 100) - (priority[right.handler] ?? 100)
-    );
-  }
-  async resolveTrigger(agent, mode = "auto") {
-    const decision = await resolveTriggerDecision({
-      agent,
-      mode,
-      isRunning: this.activeRuns.has(agent.slug),
-      lastRunAt: this.lastRunAt.get(agent.slug),
-      sdk: this.sdk.scopeForAgent(agent)
-    });
-    return decision.kind === "ready" ? decision.invocation ?? null : null;
-  }
-  async recordRunTrace(trace) {
-    await this.sdk.recordRun({ run: trace });
-  }
-  buildTrace(agent, runId, trigger, overrides) {
-    return {
-      runId,
-      agentSlug: agent.slug,
-      handlerKind: agent.handler,
-      triggerKind: trigger.kind,
-      triggerSource: trigger.source,
-      claimedMessageId: trigger.message?.id ?? null,
-      selectedItemKey: null,
-      branchName: null,
-      commitSha: null,
-      changedPaths: [],
-      summary: null,
-      error: null,
-      errorCategory: null,
-      startedAt: nowIso(),
-      finishedAt: null,
-      status: "running",
-      ...overrides
-    };
-  }
-  categorizeError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("not allowed")) {
-      return "permission_error";
-    }
-    if (message.includes("message")) {
-      return "message_claim_error";
-    }
-    if (message.includes("lease")) {
-      return "lease_error";
-    }
-    if (message.includes("commit") || message.includes("worktree") || message.includes("artifact")) {
-      return "mutation_error";
-    }
-    if (message.includes("Copilot") || message.includes("execution")) {
-      return "execution_error";
-    }
-    return "sdk_error";
-  }
-  async executeAgent(agent, trigger) {
-    if (this.activeRuns.has(agent.slug)) {
-      return {
-        status: "waiting",
-        summary: `Agent ${agent.slug} is already running.`
-      };
-    }
-    this.activeRuns.add(agent.slug);
-    const runId = crypto.randomUUID();
-    const handler = await resolveAgentHandler(agent.handler);
-    const scopedSdk = this.sdk.scopeForAgent(agent);
-    const context = {
-      runId,
-      repoRoot: this.repoRoot,
-      agent,
-      sdk: scopedSdk,
-      trigger,
-      execution: this.execution,
-      mutations: this.mutations,
-      repository: this.repository,
-      verification: this.verification,
-      notifications: this.notifications,
-      research: this.research
-    };
-    await this.recordRunTrace(this.buildTrace(agent, runId, trigger, {}));
-    try {
-      const inputs = await handler.resolveInputs(context);
-      const result = await handler.execute(context, inputs);
-      const output = await handler.emitOutputs(context, result);
-      if (trigger.message) {
-        await scopedSdk.ackMessage({
-          id: trigger.message.id,
-          status: output.status === "completed" ? "completed" : output.status === "waiting" ? "pending" : "failed"
-        });
-      }
-      await this.recordRunTrace(
-        this.buildTrace(agent, runId, trigger, {
-          status: output.status,
-          branchName: output.metadata?.branchName ?? null,
-          commitSha: output.metadata?.commitSha ?? null,
-          changedPaths: output.metadata?.changedPaths ?? [],
-          summary: output.summary,
-          error: output.status === "failed" ? output.stderr ?? output.summary : null,
-          errorCategory: output.status === "failed" ? output.errorCategory ?? "execution_error" : null,
-          finishedAt: nowIso()
-        })
-      );
-      await this.sdk.upsertCursor({
-        agentSlug: agent.slug,
-        cursorKey: "last_run_at",
-        cursorValue: nowIso()
-      });
-      if (trigger.kind === "follow") {
-        await this.sdk.upsertCursor({
-          agentSlug: agent.slug,
-          cursorKey: followCursorKey(trigger.followModels),
-          cursorValue: nowIso()
-        });
-      }
-      this.lastRunAt.set(agent.slug, Date.now());
-      return output;
-    } catch (error) {
-      if (trigger.message) {
-        await scopedSdk.ackMessage({
-          id: trigger.message.id,
-          status: "failed"
-        });
-      }
-      await this.recordRunTrace(
-        this.buildTrace(agent, runId, trigger, {
-          status: "failed",
-          error: error instanceof Error ? error.message : String(error),
-          errorCategory: this.categorizeError(error),
-          finishedAt: nowIso()
-        })
-      );
-      throw error;
-    } finally {
-      this.activeRuns.delete(agent.slug);
-    }
-  }
-  async runAgent(slug, mode = "manual", invocation) {
-    const { specs, diagnostics } = await loadActiveAgentSpecs(this.sdk);
-    const errors = diagnostics.filter((entry) => entry.severity === "error");
-    if (errors.length) {
-      throw new Error(
-        `Agent spec validation failed: ${errors.map((entry) => `${entry.slug}:${entry.field}:${entry.message}`).join(" | ")}`
-      );
-    }
-    const agents = this.sortAgents(specs);
-    const agent = agents.find((entry) => entry.slug === slug);
-    if (!agent) {
-      throw new Error(`Unknown or disabled agent "${slug}".`);
-    }
-    const trigger = invocation ?? await this.resolveTrigger(agent, mode);
-    if (!trigger) {
-      return {
-        status: "waiting",
-        summary: `No runnable trigger found for ${slug}.`
-      };
-    }
-    return this.executeAgent(agent, trigger);
-  }
-  async runCycle() {
-    const { specs, diagnostics } = await loadActiveAgentSpecs(this.sdk);
-    const errors = diagnostics.filter((entry) => entry.severity === "error");
-    if (errors.length) {
-      throw new Error(
-        `Agent spec validation failed: ${errors.map((entry) => `${entry.slug}:${entry.field}:${entry.message}`).join(" | ")}`
-      );
-    }
-    const agents = this.sortAgents(specs);
-    const results = [];
-    for (const agent of agents) {
-      const runsThisCycle = agent.triggerPolicy?.maxRunsPerCycle ?? 1;
-      for (let index = 0; index < runsThisCycle; index += 1) {
-        const trigger = await this.resolveTrigger(agent, "auto");
-        if (!trigger) {
-          break;
-        }
-        results.push({
-          slug: agent.slug,
-          result: await this.executeAgent(agent, trigger)
-        });
-      }
-    }
-    return results;
-  }
-  async start(intervalMs = Number(process.env.TREESEED_AGENT_SUPERVISOR_INTERVAL_MS ?? 6e4)) {
-    await this.runCycle();
-    setInterval(() => {
-      void this.runCycle();
-    }, intervalMs);
-  }
-  async drainMessages() {
-    const { specs, diagnostics } = await loadActiveAgentSpecs(this.sdk);
-    const errors = diagnostics.filter((entry) => entry.severity === "error");
-    if (errors.length) {
-      throw new Error(
-        `Agent spec validation failed: ${errors.map((entry) => `${entry.slug}:${entry.field}:${entry.message}`).join(" | ")}`
-      );
-    }
-    const agents = this.sortAgents(specs);
-    const messageAgents = agents.filter(
-      (agent) => agent.triggers.some((trigger) => trigger.type === "message")
-    );
-    const results = [];
-    for (const agent of messageAgents) {
-      results.push({
-        slug: agent.slug,
-        result: await this.runAgent(agent.slug, "auto")
-      });
-    }
-    return results;
-  }
-  releaseLeases() {
-    return this.sdk.releaseAllLeases();
-  }
-  async replayMessage(id) {
-    await this.sdk.ackMessage({
-      id,
-      status: "pending"
-    });
-    return {
-      id,
-      status: "pending"
-    };
-  }
-}
-export {
-  AgentKernel
-};

package/dist/agents/kernel/trigger-resolver.d.ts

@@ -1,19 +0,0 @@
-import type { AgentRuntimeSpec, AgentTriggerConfig } from '@treeseed/sdk/types/agents';
-import type { ScopedAgentSdk } from '@treeseed/sdk/sdk';
-import type { AgentTriggerInvocation } from '../runtime-types.ts';
-export type TriggerDecisionKind = 'ready' | 'skip' | 'blocked_by_cooldown' | 'blocked_by_concurrency' | 'no_message_available' | 'no_follow_activity' | 'no_trigger_available';
-export interface TriggerDecision {
-    kind: TriggerDecisionKind;
-    invocation?: AgentTriggerInvocation;
-    reason?: string;
-    selectedTrigger?: AgentTriggerConfig;
-}
-export interface TriggerResolverInput {
-    agent: AgentRuntimeSpec;
-    mode?: 'auto' | 'manual';
-    isRunning: boolean;
-    lastRunAt?: number;
-    sdk: ScopedAgentSdk;
-}
-export declare function followCursorKey(models: string[] | undefined): string;
-export declare function resolveTriggerDecision(input: TriggerResolverInput): Promise<TriggerDecision>;