@wopr-network/defcon 0.2.0 → 0.2.2

package/dist/repositories/drizzle/schema.js

@@ -1,155 +0,0 @@
-import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-// ─── Definition Tables ───
-export const flowDefinitions = sqliteTable("flow_definitions", {
-    id: text("id").primaryKey(),
-    name: text("name").notNull().unique(),
-    description: text("description"),
-    entitySchema: text("entity_schema", { mode: "json" }),
-    initialState: text("initial_state").notNull(),
-    maxConcurrent: integer("max_concurrent").default(0),
-    maxConcurrentPerRepo: integer("max_concurrent_per_repo").default(0),
-    affinityWindowMs: integer("affinity_window_ms").default(300000),
-    gateTimeoutMs: integer("gate_timeout_ms"),
-    version: integer("version").default(1),
-    createdBy: text("created_by"),
-    discipline: text("discipline"),
-    defaultModelTier: text("default_model_tier"),
-    timeoutPrompt: text("timeout_prompt"),
-    createdAt: integer("created_at"),
-    updatedAt: integer("updated_at"),
-});
-export const stateDefinitions = sqliteTable("state_definitions", {
-    id: text("id").primaryKey(),
-    flowId: text("flow_id")
-        .notNull()
-        .references(() => flowDefinitions.id),
-    name: text("name").notNull(),
-    agentRole: text("agent_role"),
-    modelTier: text("model_tier"),
-    mode: text("mode").default("passive"),
-    promptTemplate: text("prompt_template"),
-    constraints: text("constraints", { mode: "json" }),
-    onEnter: text("on_enter", { mode: "json" }),
-}, (table) => ({
-    flowNameUnique: uniqueIndex("state_definitions_flow_name_unique").on(table.flowId, table.name),
-}));
-export const gateDefinitions = sqliteTable("gate_definitions", {
-    id: text("id").primaryKey(),
-    name: text("name").notNull().unique(),
-    type: text("type").notNull(),
-    command: text("command"),
-    functionRef: text("function_ref"),
-    apiConfig: text("api_config", { mode: "json" }),
-    timeoutMs: integer("timeout_ms"),
-    failurePrompt: text("failure_prompt"),
-    timeoutPrompt: text("timeout_prompt"),
-});
-export const transitionRules = sqliteTable("transition_rules", {
-    id: text("id").primaryKey(),
-    flowId: text("flow_id")
-        .notNull()
-        .references(() => flowDefinitions.id),
-    fromState: text("from_state").notNull(),
-    toState: text("to_state").notNull(),
-    trigger: text("trigger").notNull(),
-    gateId: text("gate_id").references(() => gateDefinitions.id),
-    condition: text("condition"),
-    priority: integer("priority").default(0),
-    spawnFlow: text("spawn_flow"),
-    spawnTemplate: text("spawn_template"),
-    createdAt: integer("created_at"),
-});
-export const flowVersions = sqliteTable("flow_versions", {
-    id: text("id").primaryKey(),
-    flowId: text("flow_id")
-        .notNull()
-        .references(() => flowDefinitions.id),
-    version: integer("version").notNull(),
-    snapshot: text("snapshot", { mode: "json" }),
-    changedBy: text("changed_by"),
-    changeReason: text("change_reason"),
-    createdAt: integer("created_at"),
-}, (table) => ({
-    flowVersionUnique: uniqueIndex("flow_versions_flow_version_unique").on(table.flowId, table.version),
-}));
-// ─── Runtime Tables ───
-export const entities = sqliteTable("entities", {
-    id: text("id").primaryKey(),
-    flowId: text("flow_id")
-        .notNull()
-        .references(() => flowDefinitions.id),
-    state: text("state").notNull(),
-    refs: text("refs", { mode: "json" }),
-    artifacts: text("artifacts", { mode: "json" }),
-    claimedBy: text("claimed_by"),
-    claimedAt: integer("claimed_at"),
-    flowVersion: integer("flow_version"),
-    priority: integer("priority").default(0),
-    createdAt: integer("created_at"),
-    updatedAt: integer("updated_at"),
-    affinityWorkerId: text("affinity_worker_id"),
-    affinityRole: text("affinity_role"),
-    affinityExpiresAt: integer("affinity_expires_at"),
-}, (table) => ({
-    flowStateIdx: index("entities_flow_state_idx").on(table.flowId, table.state),
-    claimIdx: index("entities_claim_idx").on(table.flowId, table.state, table.claimedBy),
-    affinityIdx: index("entities_affinity_idx").on(table.affinityWorkerId, table.affinityRole, table.affinityExpiresAt),
-}));
-export const invocations = sqliteTable("invocations", {
-    id: text("id").primaryKey(),
-    entityId: text("entity_id")
-        .notNull()
-        .references(() => entities.id),
-    stage: text("stage").notNull(),
-    agentRole: text("agent_role"),
-    mode: text("mode").notNull(),
-    prompt: text("prompt").notNull(),
-    context: text("context", { mode: "json" }),
-    claimedBy: text("claimed_by"),
-    claimedAt: integer("claimed_at"),
-    startedAt: integer("started_at"),
-    completedAt: integer("completed_at"),
-    failedAt: integer("failed_at"),
-    signal: text("signal"),
-    artifacts: text("artifacts", { mode: "json" }),
-    error: text("error"),
-    ttlMs: integer("ttl_ms").default(1800000),
-    createdAt: integer("created_at"),
-}, (table) => ({
-    entityIdx: index("invocations_entity_idx").on(table.entityId),
-}));
-export const gateResults = sqliteTable("gate_results", {
-    id: text("id").primaryKey(),
-    entityId: text("entity_id")
-        .notNull()
-        .references(() => entities.id),
-    gateId: text("gate_id")
-        .notNull()
-        .references(() => gateDefinitions.id),
-    passed: integer("passed").notNull(),
-    output: text("output"),
-    evaluatedAt: integer("evaluated_at"),
-});
-export const entityHistory = sqliteTable("entity_history", {
-    id: text("id").primaryKey(),
-    entityId: text("entity_id")
-        .notNull()
-        .references(() => entities.id),
-    fromState: text("from_state"),
-    toState: text("to_state").notNull(),
-    trigger: text("trigger"),
-    invocationId: text("invocation_id").references(() => invocations.id),
-    timestamp: integer("timestamp").notNull(),
-}, (table) => ({
-    entityTimestampIdx: index("entity_history_entity_ts_idx").on(table.entityId, table.timestamp),
-}));
-export const events = sqliteTable("events", {
-    id: text("id").primaryKey(),
-    type: text("type").notNull(),
-    entityId: text("entity_id"),
-    flowId: text("flow_id"),
-    payload: text("payload", { mode: "json" }),
-    emittedAt: integer("emitted_at").notNull(),
-}, (table) => ({
-    typeEmittedIdx: index("events_type_emitted_idx").on(table.type, table.emittedAt),
-}));

package/dist/repositories/drizzle/transition-log.repo.d.ts

@@ -1,11 +0,0 @@
-import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
-import type { ITransitionLogRepository, TransitionLog } from "../interfaces.js";
-import type * as schema from "./schema.js";
-type Db = BetterSQLite3Database<typeof schema>;
-export declare class DrizzleTransitionLogRepository implements ITransitionLogRepository {
-    private db;
-    constructor(db: Db);
-    record(log: Omit<TransitionLog, "id">): Promise<TransitionLog>;
-    historyFor(entityId: string): Promise<TransitionLog[]>;
-}
-export {};

package/dist/repositories/drizzle/transition-log.repo.js

@@ -1,42 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { asc, eq, sql } from "drizzle-orm";
-import { entityHistory } from "./schema.js";
-export class DrizzleTransitionLogRepository {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async record(log) {
-        const id = randomUUID();
-        this.db
-            .insert(entityHistory)
-            .values({
-            id,
-            entityId: log.entityId,
-            fromState: log.fromState ?? null,
-            toState: log.toState,
-            trigger: log.trigger ?? null,
-            invocationId: log.invocationId ?? null,
-            timestamp: log.timestamp.getTime(),
-        })
-            .run();
-        return { id, ...log };
-    }
-    async historyFor(entityId) {
-        const rows = this.db
-            .select()
-            .from(entityHistory)
-            .where(eq(entityHistory.entityId, entityId))
-            .orderBy(asc(entityHistory.timestamp), sql `rowid`)
-            .all();
-        return rows.map((r) => ({
-            id: r.id,
-            entityId: r.entityId,
-            fromState: r.fromState,
-            toState: r.toState,
-            trigger: r.trigger,
-            invocationId: r.invocationId,
-            timestamp: new Date(r.timestamp),
-        }));
-    }
-}

package/dist/repositories/interfaces.d.ts

@@ -1,321 +0,0 @@
-/** External-system reference map keyed by adapter name */
-export type Refs = Record<string, {
-    adapter: string;
-    id: string;
-    [key: string]: unknown;
-}>;
-/** Freeform key-value artifact bag */
-export type Artifacts = Record<string, unknown>;
-/** Configuration for running a command when an entity enters a state */
-export interface OnEnterConfig {
-    command: string;
-    artifacts: string[];
-    timeout_ms?: number;
-}
-/** Invocation execution mode */
-export type Mode = "active" | "passive";
-/** Runtime entity tracked through a flow */
-export interface Entity {
-    id: string;
-    flowId: string;
-    state: string;
-    refs: Refs | null;
-    artifacts: Artifacts | null;
-    claimedBy: string | null;
-    claimedAt: Date | null;
-    flowVersion: number;
-    priority: number;
-    createdAt: Date;
-    updatedAt: Date;
-    affinityWorkerId: string | null;
-    affinityRole: string | null;
-    affinityExpiresAt: Date | null;
-}
-/** A single agent invocation tied to an entity */
-export interface Invocation {
-    id: string;
-    entityId: string;
-    stage: string;
-    mode: Mode;
-    prompt: string;
-    context: Record<string, unknown> | null;
-    claimedBy: string | null;
-    claimedAt: Date | null;
-    startedAt: Date | null;
-    completedAt: Date | null;
-    failedAt: Date | null;
-    signal: string | null;
-    artifacts: Artifacts | null;
-    error: string | null;
-    ttlMs: number;
-}
-/** Result of evaluating a gate against an entity */
-export interface GateResult {
-    id: string;
-    entityId: string;
-    gateId: string;
-    passed: boolean;
-    output: string | null;
-    evaluatedAt: Date | null;
-}
-/**
- * Entity with pre-fetched related data for use in Handlebars template helpers.
- * The `invocations` and `gateResults` fields are populated by the engine before
- * rendering prompt templates; they are never present on raw DB rows.
- */
-export interface EnrichedEntity extends Entity {
-    invocations?: Invocation[];
-    gateResults?: GateResult[];
-}
-/** Audit-log entry for an entity state transition */
-export interface TransitionLog {
-    id: string;
-    entityId: string;
-    fromState: string | null;
-    toState: string;
-    trigger: string | null;
-    invocationId: string | null;
-    timestamp: Date;
-}
-/** A state within a flow definition */
-export interface State {
-    id: string;
-    flowId: string;
-    name: string;
-    modelTier: string | null;
-    mode: Mode;
-    promptTemplate: string | null;
-    constraints: Record<string, unknown> | null;
-    onEnter: OnEnterConfig | null;
-}
-/** A transition rule between two states */
-export interface Transition {
-    id: string;
-    flowId: string;
-    fromState: string;
-    toState: string;
-    trigger: string;
-    gateId: string | null;
-    condition: string | null;
-    priority: number;
-    spawnFlow: string | null;
-    spawnTemplate: string | null;
-    createdAt: Date | null;
-}
-/** A gate definition (quality check) */
-export interface Gate {
-    id: string;
-    name: string;
-    type: string;
-    command: string | null;
-    functionRef: string | null;
-    apiConfig: Record<string, unknown> | null;
-    timeoutMs: number | null;
-    failurePrompt: string | null;
-    timeoutPrompt: string | null;
-}
-/** A complete flow definition with its states and transitions */
-export interface Flow {
-    id: string;
-    name: string;
-    description: string | null;
-    entitySchema: Record<string, unknown> | null;
-    initialState: string;
-    maxConcurrent: number;
-    maxConcurrentPerRepo: number;
-    affinityWindowMs: number;
-    gateTimeoutMs: number | null;
-    version: number;
-    createdBy: string | null;
-    discipline: string | null;
-    defaultModelTier: string | null;
-    timeoutPrompt: string | null;
-    createdAt: Date | null;
-    updatedAt: Date | null;
-    states: State[];
-    transitions: Transition[];
-}
-/** A versioned snapshot of a flow */
-export interface FlowVersion {
-    id: string;
-    flowId: string;
-    version: number;
-    snapshot: Record<string, unknown>;
-    changedBy: string | null;
-    changeReason: string | null;
-    createdAt: Date | null;
-}
-/** Input for creating a new flow */
-export interface CreateFlowInput {
-    name: string;
-    description?: string;
-    entitySchema?: Record<string, unknown>;
-    initialState: string;
-    maxConcurrent?: number;
-    maxConcurrentPerRepo?: number;
-    affinityWindowMs?: number;
-    gateTimeoutMs?: number;
-    createdBy?: string;
-    discipline?: string;
-    defaultModelTier?: string;
-    timeoutPrompt?: string;
-}
-/** Input for adding a state to a flow */
-export interface CreateStateInput {
-    name: string;
-    modelTier?: string;
-    mode?: Mode;
-    promptTemplate?: string;
-    constraints?: Record<string, unknown>;
-    onEnter?: OnEnterConfig;
-}
-/** Input for adding a transition rule */
-export interface CreateTransitionInput {
-    fromState: string;
-    toState: string;
-    trigger: string;
-    gateId?: string;
-    condition?: string;
-    priority?: number;
-    spawnFlow?: string;
-    spawnTemplate?: string;
-}
-/** Input for creating a gate definition */
-export interface CreateGateInput {
-    name: string;
-    type: string;
-    command?: string;
-    functionRef?: string;
-    apiConfig?: Record<string, unknown>;
-    timeoutMs?: number;
-    failurePrompt?: string;
-    timeoutPrompt?: string;
-}
-/** Data-access contract for entity lifecycle operations. */
-export interface IEntityRepository {
-    /** Create a new entity in the given flow's initial state. */
-    create(flowId: string, initialState: string, refs?: Refs): Promise<Entity>;
-    /** Get an entity by ID, or null if not found. */
-    get(id: string): Promise<Entity | null>;
-    /** Find entities in a given flow and state, up to an optional limit. */
-    findByFlowAndState(flowId: string, state: string, limit?: number): Promise<Entity[]>;
-    /** Return true if at least one entity exists in the given flow across any of the given states. */
-    hasAnyInFlowAndState(flowId: string, stateNames: string[]): Promise<boolean>;
-    /** Transition an entity to a new state, recording the trigger and optional artifacts. */
-    transition(id: string, toState: string, trigger: string, artifacts?: Partial<Artifacts>): Promise<Entity>;
-    /** Merge partial artifacts into an entity's existing artifact bag. Performs a shallow merge
-     *  ({ ...existing, ...artifacts }) — only the specified keys are updated; unspecified keys are preserved. */
-    updateArtifacts(id: string, artifacts: Partial<Artifacts>): Promise<void>;
-    /** Atomically claim one unclaimed entity in the given flow+state for the specified agent. Returns null if none available. Uses compare-and-swap (UPDATE WHERE claimedBy IS NULL). */
-    claim(flowId: string, state: string, agentId: string): Promise<Entity | null>;
-    /** Atomically claim a specific entity by ID for the specified agent. Returns null if already claimed. Uses compare-and-swap (UPDATE WHERE claimedBy IS NULL). */
-    claimById(entityId: string, agentId: string): Promise<Entity | null>;
-    /** Release a claimed entity, clearing claimedBy and claimedAt. */
-    release(entityId: string, agentId: string): Promise<void>;
-    /** Find entities whose claim has expired beyond ttlMs and release them. Returns the IDs of released entities. */
-    reapExpired(ttlMs: number): Promise<string[]>;
-    /** Set affinity metadata on an entity, recording the last worker that touched it. */
-    setAffinity(entityId: string, workerId: string, role: string, expiresAt: Date): Promise<void>;
-    /** Clear expired affinity records. Returns the IDs of entities whose affinity was cleared. */
-    clearExpiredAffinity(): Promise<string[]>;
-    /** Atomically append a spawned child entry to the parent entity's artifacts.spawnedChildren array.
-     *  Reads the current array and writes back in a single transaction to prevent TOCTOU races. */
-    appendSpawnedChild(parentId: string, entry: {
-        childId: string;
-        childFlow: string;
-        spawnedAt: string;
-    }): Promise<void>;
-}
-/** Fields that can be updated on a flow's top-level definition */
-export type UpdateFlowInput = Partial<Omit<Flow, "id" | "states" | "transitions" | "createdAt" | "updatedAt">>;
-/** Fields that can be updated on a state definition */
-export type UpdateStateInput = Partial<Omit<State, "id" | "flowId">>;
-/** Fields that can be updated on a transition rule */
-export type UpdateTransitionInput = Partial<Omit<Transition, "id" | "flowId">>;
-/** Data-access contract for flow definition CRUD and versioning. */
-export interface IFlowRepository {
-    /** Create a new flow definition. */
-    create(flow: CreateFlowInput): Promise<Flow>;
-    /** List all flow definitions. */
-    list(): Promise<Flow[]>;
-    /** Get a flow by ID, including its states and transitions. Returns null if not found. */
-    get(id: string): Promise<Flow | null>;
-    /** Get a flow by unique name. Returns null if not found. */
-    getByName(name: string): Promise<Flow | null>;
-    /** Update a flow's top-level fields. */
-    update(id: string, changes: UpdateFlowInput): Promise<Flow>;
-    /** Add a state definition to a flow. */
-    addState(flowId: string, state: CreateStateInput): Promise<State>;
-    /** Update an existing state definition. */
-    updateState(stateId: string, changes: UpdateStateInput): Promise<State>;
-    /** Add a transition rule to a flow. */
-    addTransition(flowId: string, transition: CreateTransitionInput): Promise<Transition>;
-    /** Update an existing transition rule. */
-    updateTransition(transitionId: string, changes: UpdateTransitionInput): Promise<Transition>;
-    /** Create a versioned snapshot of the current flow definition. */
-    snapshot(flowId: string): Promise<FlowVersion>;
-    /** Restore a flow definition to a previous version. */
-    restore(flowId: string, version: number): Promise<void>;
-    /** List all flow definitions. */
-    listAll(): Promise<Flow[]>;
-}
-/** Data-access contract for invocation lifecycle and claiming. */
-export interface IInvocationRepository {
-    /** Create a new invocation for an entity at a given stage. */
-    create(entityId: string, stage: string, prompt: string, mode: Mode, ttlMs?: number, context?: Record<string, unknown>): Promise<Invocation>;
-    /** Get an invocation by ID, or null if not found. */
-    get(id: string): Promise<Invocation | null>;
-    /** Atomically claim an unclaimed invocation for the specified agent. Uses compare-and-swap (UPDATE WHERE claimedBy IS NULL). Returns null if already claimed. */
-    claim(invocationId: string, agentId: string): Promise<Invocation | null>;
-    /** Mark an invocation as completed with a signal and optional artifacts. */
-    complete(id: string, signal: string, artifacts?: Artifacts): Promise<Invocation>;
-    /** Mark an invocation as failed with an error message. */
-    fail(id: string, error: string): Promise<Invocation>;
-    /** Release a claim on an invocation, making it available for another worker to claim. */
-    releaseClaim(id: string): Promise<void>;
-    /** Find all invocations for a given entity. */
-    findByEntity(entityId: string): Promise<Invocation[]>;
-    /** Find unclaimed invocations where the entity has unexpired affinity for the given worker and role. */
-    findUnclaimedWithAffinity(flowId: string, role: string, workerId: string): Promise<Invocation[]>;
-    /** Find all unclaimed invocations in a flow, regardless of agentRole. For discipline-based claiming. */
-    findUnclaimedByFlow(flowId: string): Promise<Invocation[]>;
-    /** Find all invocations for a given flow (across all entities). */
-    findByFlow(flowId: string): Promise<Invocation[]>;
-    /** Find and mark expired invocations (where now - claimedAt > row's ttlMs). Returns the expired invocations. */
-    reapExpired(): Promise<Invocation[]>;
-    /** Find unclaimed active-mode invocations, optionally filtered by flow. */
-    findUnclaimedActive(flowId?: string): Promise<Invocation[]>;
-    /** Count active invocations (claimed, not completed/failed) for a flow. */
-    countActiveByFlow(flowId: string): Promise<number>;
-    /** Count pending invocations (unclaimed, not completed/failed) for a flow. */
-    countPendingByFlow(flowId: string): Promise<number>;
-}
-/** Data-access contract for entity state-transition audit trails. */
-export interface ITransitionLogRepository {
-    /** Record a state transition for an entity. */
-    record(log: Omit<TransitionLog, "id">): Promise<TransitionLog>;
-    /** Get full transition history for an entity, ordered by timestamp. */
-    historyFor(entityId: string): Promise<TransitionLog[]>;
-}
-/** Data-access contract for emitting definition-change events. */
-export interface IEventRepository {
-    /** Emit a definition change event for a tool action. */
-    emitDefinitionChanged(flowId: string | null, tool: string, payload: Record<string, unknown>): Promise<void>;
-}
-/** Data-access contract for gate definitions and result recording. */
-export interface IGateRepository {
-    /** Create a new gate definition. */
-    create(gate: CreateGateInput): Promise<Gate>;
-    /** Get a gate by ID, or null if not found. */
-    get(id: string): Promise<Gate | null>;
-    /** Get a gate by unique name, or null if not found. */
-    getByName(name: string): Promise<Gate | null>;
-    /** List all gate definitions. */
-    listAll(): Promise<Gate[]>;
-    /** Record the result of evaluating a gate against an entity. */
-    record(entityId: string, gateId: string, passed: boolean, output: string): Promise<GateResult>;
-    /** Get all gate results for a given entity. */
-    resultsFor(entityId: string): Promise<GateResult[]>;
-    /** Update mutable fields on a gate definition. */
-    update(id: string, changes: Partial<Pick<Gate, "command" | "functionRef" | "apiConfig" | "timeoutMs" | "failurePrompt" | "timeoutPrompt">>): Promise<Gate>;
-}

package/dist/repositories/interfaces.js

@@ -1,2 +0,0 @@
-// Repository interfaces — I*Repository contracts
-export {};

package/dist/utils/redact.d.ts

@@ -1,2 +0,0 @@
-export declare function redactString(value: string, maxLength?: number): string;
-export declare function redact(value: unknown): unknown;

package/dist/utils/redact.js

@@ -1,62 +0,0 @@
-// Sensitive term must appear as a whole word component in camelCase/snake_case keys.
-// Split on underscores and camelCase boundaries before matching, so e.g. "authHeader"
-// is redacted (contains "auth" as a component) but "authorId" is not ("author" ≠ "auth").
-const SENSITIVE_TERMS = new Set(["token", "key", "secret", "password", "bearer", "auth", "credential"]);
-function isSensitiveKey(k) {
-    // Split on: underscores, spaces, or camelCase transitions (lower→upper, upper→upper+lower)
-    const words = k.split(/[_\s]+|(?<=[a-z\d])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/);
-    return words.some((w) => SENSITIVE_TERMS.has(w.toLowerCase()));
-}
-const DESCRIPTION_MAX = 100;
-// Patterns to strip from string content
-const CREDENTIAL_PATTERNS = [
-    /Bearer\s+\S+/gi,
-    /\bsk-ant-\S+/gi,
-    /\bsk-\S{20,}/gi,
-    /(?:password|secret|token|key|auth)[\s]*[=:]\s*\S+/gi,
-];
-export function redactString(value, maxLength = 500) {
-    let result = value;
-    for (const pattern of CREDENTIAL_PATTERNS) {
-        result = result.replace(pattern, "[REDACTED]");
-    }
-    if (result.length > maxLength) {
-        result = `${result.slice(0, maxLength)}...`;
-    }
-    return result;
-}
-export function redact(value) {
-    return walk(value, new WeakSet());
-}
-function walk(value, seen) {
-    if (value === null || value === undefined)
-        return value;
-    if (typeof value !== "object")
-        return value;
-    if (value instanceof Date)
-        return value;
-    if (value instanceof Error) {
-        return walk({ name: value.name, message: value.message, stack: value.stack }, seen);
-    }
-    const obj = value;
-    if (seen.has(obj))
-        return "[Circular]";
-    seen.add(obj);
-    if (Array.isArray(obj)) {
-        return obj.map((item) => walk(item, seen));
-    }
-    const result = {};
-    for (const k of Object.keys(obj)) {
-        const v = obj[k];
-        if (isSensitiveKey(k)) {
-            result[k] = "[REDACTED]";
-        }
-        else if (k === "description" && typeof v === "string" && v.length > DESCRIPTION_MAX) {
-            result[k] = `${v.slice(0, DESCRIPTION_MAX)}...`;
-        }
-        else {
-            result[k] = walk(v, seen);
-        }
-    }
-    return result;
-}

package/gates/blocking-graph.d.ts

@@ -1,26 +0,0 @@
-/**
- * Custom gate: checks whether all Linear blockers for an entity's issue
- * have corresponding merged PRs on GitHub.
- *
- * Referenced by seed as: "gates/blocking-graph.ts:isUnblocked"
- *
- * NOTE: Function gates are not yet evaluated by the engine (gate-evaluator.ts
- * throws for type "function"). This file exists as the implementation target
- * for when function gate support lands.
- *
- * NOTE: This file is intentionally outside src/ — it is loaded dynamically at
- * runtime, not compiled by the main build.
- */
-import type { Entity } from "../src/repositories/interfaces.js";
-export interface BlockingGraphResult {
-    passed: boolean;
-    output: string;
-}
-/**
- * Check if all blocking issues for the given entity have merged PRs.
- *
- * Expects entity.refs.linear.id to be the Linear issue ID.
- * Uses LINEAR_API_KEY env var for authentication.
- * Uses `gh` CLI to check PR merge status on GitHub.
- */
-export declare function isUnblocked(entity: Entity): Promise<BlockingGraphResult>;