@treeseed/sdk 0.13.0-rc.119 → 0.13.0-rc.120

package/dist/agent-capacity/contracts/capacity/assignments/agent-execution.js

@@ -57,7 +57,15 @@ const effectiveActivityProfileSchema = activityProfileSchema.omit({ dependsOn: t
   handlerOrigin: z.enum(["agent-package", "project-runtime"]),
   permissionCeiling: activityProfileSchema.shape.permissions
 }).omit({ permissions: true }).strict();
-const providerSelectionSchema = z.object({ providerId: identifier, offerId: identifier, offerRevision: z.number().int().positive(), runtimeBuild: digest }).strict();
+const providerSelectionSchema = z.object({
+  providerId: identifier,
+  offerId: identifier,
+  executionProviderId: identifier,
+  modelConfigurationId: identifier,
+  executionCapabilityId: identifier,
+  offerRevision: z.number().int().positive(),
+  runtimeBuild: digest
+}).strict();
 const limitsSchema = z.object({
   maximumSeconds: z.number().int().positive(),
   maximumContextBytes: z.number().int().positive(),
@@ -115,6 +123,17 @@ const diagnosticSchema = z.object({
   message: z.string().min(1),
   ref: exactEntityReferenceSchema.optional()
 }).strict();
+const assignmentTimingAwarenessReceiptSchema = z.object({
+  schemaVersion: z.literal("treeseed.assignment-timing-awareness/v1"),
+  requiredChecks: z.literal(2),
+  completedChecks: z.number().int().min(2),
+  firstTool: z.literal("treedx:treeseed_time_status"),
+  firstToolSucceeded: z.literal(true),
+  lastTool: z.literal("treedx:treeseed_time_status"),
+  lastToolSucceeded: z.literal(true),
+  firstToolCompliant: z.literal(true),
+  finalToolCompliant: z.literal(true)
+}).strict();
 const assignmentResultSchema = z.object({
   schemaVersion: z.literal("treeseed.assignment-result/v1"),
   id: identifier,
@@ -125,6 +144,7 @@ const assignmentResultSchema = z.object({
   verification: z.array(verificationRecordSchema),
   usage: usageSchema,
   diagnostics: z.array(diagnosticSchema),
+  timingAwareness: assignmentTimingAwarenessReceiptSchema.optional(),
   completedAt: timestamp
 }).strict();
 const authorizedContextItemSchema = z.object({
@@ -143,6 +163,7 @@ export {
   assignmentContextSchema,
   assignmentReferenceSchema,
   assignmentResultSchema,
+  assignmentTimingAwarenessReceiptSchema,
   assignmentWorkspaceSchema,
   authorizedContextItemSchema,
   diagnosticSchema,

package/dist/agent-capacity/contracts/capacity/assignments/assignment-records.d.ts

@@ -212,6 +212,11 @@ export interface ProviderAssignment {
     updatedAt: string;
 }
 export interface ProviderAssignmentLifecycleRequest {
+    activeSeconds?: number | null;
+    elapsedSeconds?: number | null;
+    actualUsd?: number | null;
+    providerUnits?: number | null;
+    usage?: Record<string, unknown> | null;
     runnerId?: string | null;
     leaseToken?: string | null;
     leaseSeconds?: number | null;

package/dist/agent-capacity/contracts/capacity/workdays/assignment-allocation.d.ts

@@ -0,0 +1,82 @@
+/** Pure allocation arithmetic. Admission must reserve the returned amount atomically. */
+import { type AppliedWorkday } from './workday-allocation.js';
+export interface AllocationShare {
+    id: string;
+    weight: number;
+    committedSeconds: number;
+    maximumAdditionalSeconds: number;
+}
+/** Redistributable shares; existing reservations/consumption retain their entitlement. */
+export declare function distributeAllocationSeconds(remainingSeconds: number, shares: AllocationShare[]): Record<string, number>;
+/** Resolve each live workday's phase opportunity from the same shared hard supply.
+ * maximumAdditionalSeconds is graph-ready demand, bounded by supply windows/concurrency.
+ * Existing commitments are never resized; execution mode does not alter entitlement.
+ */
+export declare function allocateWorkdayCapacity(input: {
+    remainingSeconds: number;
+    now: string;
+    workdays: Array<{
+        plan: AppliedWorkday;
+        committedSeconds: number;
+        planningCommittedSeconds: number;
+        maximumAdditionalSeconds: number;
+    }>;
+}): {
+    [k: string]: {
+        shareSeconds: number;
+        phase: "planning" | "ended" | "acting";
+        phaseRemainingSeconds: number;
+        weight: number;
+        committedSeconds: number;
+        planningCommittedSeconds: number;
+        remainingSupplySeconds: number;
+        totalEligibleWeight: number;
+        availableSeconds: number;
+    };
+};
+export interface AllocationMeasurement {
+    id: string;
+    completedAt: string;
+    expectedSeconds: number;
+    allocatedSeconds: number;
+    activeSeconds: number;
+    outcome: 'completed' | 'expired' | 'cancelled' | 'credential-failure' | 'infrastructure-failure' | 'invalid-result';
+}
+/** Caller scopes history to exact provider/model, capability, class, and activity. */
+export declare function calibrateAssignmentSeconds(estimate: {
+    expectedSeconds: number;
+    maximumSeconds: number;
+}, measurements: AllocationMeasurement[]): {
+    seconds: number;
+    multiplier: number;
+    measurementIds: string[];
+};
+export interface AssignmentAllocationConstraint {
+    id: string;
+    remainingSeconds: number;
+}
+export declare function calculateAssignmentAllocation(input: {
+    estimate: {
+        minimumSeconds: number;
+        expectedSeconds: number;
+        maximumSeconds: number;
+    };
+    measurements: AllocationMeasurement[];
+    constraints: AssignmentAllocationConstraint[];
+    providerMinimumSeconds?: number;
+    providerMaximumSeconds?: number;
+    profileMaximumSeconds?: number;
+    planningTurnMaximumSeconds?: number;
+}): {
+    admitted: boolean;
+    allocatedSeconds: number;
+    minimumSeconds: number;
+    desiredSeconds: number;
+    calibration: {
+        seconds: number;
+        multiplier: number;
+        measurementIds: string[];
+    };
+    limitingConstraint: string;
+    constraints: AssignmentAllocationConstraint[];
+};

package/dist/agent-capacity/contracts/capacity/workdays/assignment-allocation.js

@@ -0,0 +1,115 @@
+import { workdayPhase } from "./workday-allocation.js";
+function nonnegative(value) {
+  if (!Number.isFinite(value) || value < 0) throw new Error("allocation_amount_invalid");
+  return value;
+}
+function distributeAllocationSeconds(remainingSeconds, shares) {
+  nonnegative(remainingSeconds);
+  if (new Set(shares.map((share) => share.id)).size !== shares.length) throw new Error("allocation_share_duplicate");
+  const ordered = [...shares].sort((a, b) => a.id.localeCompare(b.id));
+  for (const share of ordered) {
+    if (!Number.isFinite(share.weight) || share.weight <= 0) throw new Error("allocation_weight_invalid");
+    nonnegative(share.committedSeconds);
+    nonnegative(share.maximumAdditionalSeconds);
+  }
+  const result = Object.fromEntries(ordered.map((share) => [share.id, 0]));
+  const capacity = Math.min(remainingSeconds, ordered.reduce((sum, share) => sum + share.maximumAdditionalSeconds, 0));
+  if (!capacity) return result;
+  let low = 0;
+  let high = Math.max(...ordered.map((share) => (share.committedSeconds + capacity) / share.weight));
+  for (let iteration = 0; iteration < 80; iteration += 1) {
+    const level = (low + high) / 2;
+    const amount = ordered.reduce((sum, share) => sum + Math.min(
+      share.maximumAdditionalSeconds,
+      Math.max(0, level * share.weight - share.committedSeconds)
+    ), 0);
+    if (amount > capacity) high = level;
+    else low = level;
+  }
+  for (const share of ordered) result[share.id] = Math.floor(Math.min(
+    share.maximumAdditionalSeconds,
+    Math.max(0, low * share.weight - share.committedSeconds)
+  ) + 1e-9);
+  let residual = Math.floor(capacity) - Object.values(result).reduce((sum, amount) => sum + amount, 0);
+  for (const share of [...ordered].sort((a, b) => (a.committedSeconds + result[a.id]) / a.weight - (b.committedSeconds + result[b.id]) / b.weight || a.id.localeCompare(b.id))) {
+    if (residual > 0 && result[share.id] + 1 <= share.maximumAdditionalSeconds) {
+      result[share.id] += 1;
+      residual -= 1;
+    }
+  }
+  return result;
+}
+function allocateWorkdayCapacity(input) {
+  if (!Number.isFinite(Date.parse(input.now))) throw new Error("allocation_time_invalid");
+  const shares = input.workdays.map(({ plan, committedSeconds, planningCommittedSeconds, maximumAdditionalSeconds }) => {
+    nonnegative(planningCommittedSeconds);
+    if (planningCommittedSeconds > committedSeconds) throw new Error("allocation_planning_commitment_invalid");
+    const eligible = Date.parse(input.now) >= Date.parse(plan.startsAt) && (plan.state === "closing" || plan.state === "active" && workdayPhase(plan, input.now) !== "ended");
+    return {
+      id: plan.id,
+      weight: plan.policySnapshot.allocationWeight,
+      committedSeconds,
+      maximumAdditionalSeconds: eligible ? maximumAdditionalSeconds : 0
+    };
+  });
+  const opportunities = distributeAllocationSeconds(input.remainingSeconds, shares);
+  return Object.fromEntries(input.workdays.map(({ plan, committedSeconds, planningCommittedSeconds }) => {
+    const shareSeconds = opportunities[plan.id];
+    const phase = plan.state === "closing" ? "acting" : workdayPhase(plan, input.now);
+    const phaseRemainingSeconds = phase === "planning" ? Math.max(0, Math.floor((committedSeconds + shareSeconds) * plan.policySnapshot.planningPercent / 100) - planningCommittedSeconds) : shareSeconds;
+    return [plan.id, {
+      shareSeconds,
+      phase,
+      phaseRemainingSeconds,
+      weight: plan.policySnapshot.allocationWeight,
+      committedSeconds,
+      planningCommittedSeconds,
+      remainingSupplySeconds: input.remainingSeconds,
+      totalEligibleWeight: shares.filter((share) => share.maximumAdditionalSeconds > 0).reduce((sum, share) => sum + share.weight, 0),
+      availableSeconds: Math.min(shareSeconds, phaseRemainingSeconds)
+    }];
+  }));
+}
+function calibrateAssignmentSeconds(estimate, measurements) {
+  if (!Number.isFinite(estimate.expectedSeconds) || estimate.expectedSeconds <= 0 || !Number.isFinite(estimate.maximumSeconds) || estimate.maximumSeconds < estimate.expectedSeconds) throw new Error("allocation_estimate_invalid");
+  const eligible = measurements.filter((entry) => entry.outcome === "completed" || entry.outcome === "expired").sort((a, b) => Date.parse(a.completedAt) - Date.parse(b.completedAt) || a.id.localeCompare(b.id)).slice(-20);
+  let multiplier = estimate.maximumSeconds / estimate.expectedSeconds;
+  for (const entry of eligible) {
+    if (!Number.isFinite(Date.parse(entry.completedAt)) || !Number.isFinite(entry.expectedSeconds) || entry.expectedSeconds <= 0 || !Number.isFinite(entry.allocatedSeconds) || entry.allocatedSeconds <= 0) throw new Error("allocation_measurement_invalid");
+    nonnegative(entry.activeSeconds);
+    const ratio = entry.activeSeconds / entry.expectedSeconds;
+    multiplier = entry.outcome === "expired" ? Math.max(multiplier * 1.25, entry.allocatedSeconds / entry.expectedSeconds * 1.25, ratio * 1.25) : Math.max(multiplier * 0.9, ratio * 1.25);
+  }
+  return { seconds: Math.ceil(estimate.expectedSeconds * multiplier), multiplier, measurementIds: eligible.map((entry) => entry.id) };
+}
+function calculateAssignmentAllocation(input) {
+  const calibration = calibrateAssignmentSeconds(input.estimate, input.measurements);
+  const minimumSeconds = Math.max(1, nonnegative(input.estimate.minimumSeconds), nonnegative(input.providerMinimumSeconds ?? 1));
+  const constraints = [...input.constraints];
+  for (const [id, value] of [
+    ["provider-maximum", input.providerMaximumSeconds],
+    ["profile-maximum", input.profileMaximumSeconds],
+    ["planning-turn", input.planningTurnMaximumSeconds]
+  ]) if (value !== void 0) constraints.push({ id, remainingSeconds: nonnegative(value) });
+  if (!constraints.length) throw new Error("allocation_constraints_required");
+  for (const entry of constraints) nonnegative(entry.remainingSeconds);
+  constraints.sort((a, b) => a.remainingSeconds - b.remainingSeconds || a.id.localeCompare(b.id));
+  const availableSeconds = Math.floor(constraints[0].remainingSeconds);
+  const desiredSeconds = input.planningTurnMaximumSeconds ?? calibration.seconds;
+  const allocatedSeconds = Math.min(Math.max(minimumSeconds, desiredSeconds), availableSeconds);
+  return {
+    admitted: availableSeconds >= minimumSeconds,
+    allocatedSeconds: availableSeconds >= minimumSeconds ? allocatedSeconds : 0,
+    minimumSeconds,
+    desiredSeconds,
+    calibration,
+    limitingConstraint: availableSeconds < Math.max(minimumSeconds, desiredSeconds) ? constraints[0].id : "task-duration",
+    constraints
+  };
+}
+export {
+  allocateWorkdayCapacity,
+  calculateAssignmentAllocation,
+  calibrateAssignmentSeconds,
+  distributeAllocationSeconds
+};

package/dist/agent-capacity/contracts/capacity/workdays/capability-accounting.d.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+/** Provider-owned configuration, carried in the existing adapter nativeLimits. */
+export declare const capabilityAccountingLimitsSchema: z.ZodObject<{
+    modelConfigurationId: z.ZodString;
+    dailyActiveSecondsLimit: z.ZodNumber;
+    capabilityLimits: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+        dailyActiveSecondsLimit: z.ZodNumber;
+        minimumAssignmentSeconds: z.ZodOptional<z.ZodNumber>;
+        maximumAssignmentSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>>, Record<string, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>, Record<string, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    modelConfigurationId: z.ZodString;
+    dailyActiveSecondsLimit: z.ZodNumber;
+    capabilityLimits: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+        dailyActiveSecondsLimit: z.ZodNumber;
+        minimumAssignmentSeconds: z.ZodOptional<z.ZodNumber>;
+        maximumAssignmentSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>>, Record<string, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>, Record<string, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    modelConfigurationId: z.ZodString;
+    dailyActiveSecondsLimit: z.ZodNumber;
+    capabilityLimits: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+        dailyActiveSecondsLimit: z.ZodNumber;
+        minimumAssignmentSeconds: z.ZodOptional<z.ZodNumber>;
+        maximumAssignmentSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>>, Record<string, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>, Record<string, {
+        dailyActiveSecondsLimit: number;
+        minimumAssignmentSeconds?: number | undefined;
+        maximumAssignmentSeconds?: number | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type CapabilityAccountingLimits = z.infer<typeof capabilityAccountingLimitsSchema>;
+export interface CapabilityAccountingObservation {
+    day: string;
+    observedAt: string;
+    healthy: boolean;
+    activeSeconds: number;
+    reservedSeconds: number;
+}
+/** Totals must cover the same accounting scope: provider/model or capability. */
+export declare function remainingCapabilitySeconds(input: {
+    now: string;
+    maximumObservationAgeSeconds: number;
+    dailyLimitSeconds: number;
+    observation: CapabilityAccountingObservation;
+    previousObservation?: CapabilityAccountingObservation;
+    ledgerActiveSeconds: number;
+    /** Unconsumed portions of outstanding reservations; active portions are already usage. */
+    ledgerReservedSeconds: number;
+}): {
+    availableSeconds: number;
+    reason: "non-monotonic";
+    activeSeconds?: undefined;
+    reservedSeconds?: undefined;
+    day?: undefined;
+} | {
+    availableSeconds: number;
+    reason: "unhealthy";
+    activeSeconds?: undefined;
+    reservedSeconds?: undefined;
+    day?: undefined;
+} | {
+    availableSeconds: number;
+    reason: "stale";
+    activeSeconds?: undefined;
+    reservedSeconds?: undefined;
+    day?: undefined;
+} | {
+    availableSeconds: number;
+    reason: "accounted";
+    activeSeconds: number;
+    reservedSeconds: number;
+    day: string;
+};

package/dist/agent-capacity/contracts/capacity/workdays/capability-accounting.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+const capabilityAccountingLimitsSchema = z.object({
+  modelConfigurationId: z.string().trim().min(1),
+  dailyActiveSecondsLimit: z.number().finite().nonnegative(),
+  capabilityLimits: z.record(z.object({
+    dailyActiveSecondsLimit: z.number().finite().nonnegative(),
+    minimumAssignmentSeconds: z.number().int().positive().optional(),
+    maximumAssignmentSeconds: z.number().int().positive().optional()
+  }).strict().superRefine((value, context) => {
+    if (value.minimumAssignmentSeconds !== void 0 && value.maximumAssignmentSeconds !== void 0 && value.minimumAssignmentSeconds > value.maximumAssignmentSeconds) context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["maximumAssignmentSeconds"],
+      message: "Maximum must not be below minimum."
+    });
+  })).refine((value) => Object.keys(value).length > 0, "At least one execution capability limit is required.")
+}).passthrough();
+function remainingCapabilitySeconds(input) {
+  const now = Date.parse(input.now), observed = Date.parse(input.observation.observedAt);
+  const numbers = [
+    input.maximumObservationAgeSeconds,
+    input.dailyLimitSeconds,
+    input.observation.activeSeconds,
+    input.observation.reservedSeconds,
+    input.ledgerActiveSeconds,
+    input.ledgerReservedSeconds
+  ];
+  if (!numbers.every((value) => Number.isFinite(value) && value >= 0) || !Number.isFinite(now) || !Number.isFinite(observed)) throw new Error("capability_accounting_invalid");
+  const day = new Date(now).toISOString().slice(0, 10);
+  const previous = input.previousObservation;
+  if (previous && (!Number.isFinite(Date.parse(previous.observedAt)) || !Number.isFinite(previous.activeSeconds) || previous.activeSeconds < 0)) throw new Error("capability_accounting_invalid");
+  if (previous && (observed < Date.parse(previous.observedAt) || previous.day === day && input.observation.activeSeconds < previous.activeSeconds)) {
+    return { availableSeconds: 0, reason: "non-monotonic" };
+  }
+  if (!input.observation.healthy) return { availableSeconds: 0, reason: "unhealthy" };
+  if (input.observation.day !== day || new Date(observed).toISOString().slice(0, 10) !== day || observed > now || now - observed > input.maximumObservationAgeSeconds * 1e3) {
+    return { availableSeconds: 0, reason: "stale" };
+  }
+  const activeSeconds = Math.max(input.observation.activeSeconds, input.ledgerActiveSeconds);
+  const reservedSeconds = Math.max(input.observation.reservedSeconds, input.ledgerReservedSeconds);
+  return {
+    availableSeconds: Math.max(0, Math.floor(input.dailyLimitSeconds - activeSeconds - reservedSeconds)),
+    reason: "accounted",
+    activeSeconds,
+    reservedSeconds,
+    day
+  };
+}
+export {
+  capabilityAccountingLimitsSchema,
+  remainingCapabilitySeconds
+};