patchwarden 1.1.0 → 1.5.1

package/dist/tools/runTaskLoop.js

@@ -0,0 +1,417 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { getConfig } from "../config.js";
+import { createWorktree } from "../goal/worktreeManager.js";
+import { guardWorkspacePath } from "../security/pathGuard.js";
+import { createDirectSession } from "./createDirectSession.js";
+import { createTask } from "./createTask.js";
+import { recommendAgentForTask } from "./recommendAgentForTask.js";
+import { runDirectVerificationBundle } from "./runDirectVerificationBundle.js";
+import { waitForTask } from "./waitForTask.js";
+import { safeAudit, safeAuditDirectSession, safeFinalizeDirectSession, safeResult, safeTestSummary } from "./safeViews.js";
+import { createLineageId, writeTaskLineage, } from "./taskLineage.js";
+const DEFAULT_DEPS = {
+    createTask,
+    waitForTask,
+    safeResult,
+    safeAudit,
+    safeTestSummary,
+    createDirectSession,
+    runDirectVerificationBundle,
+    safeFinalizeDirectSession,
+    safeAuditDirectSession,
+    writeTaskLineage,
+    createLineageId,
+    recommendAgentForTask,
+    createWorktree,
+    now: () => new Date(),
+    sleep,
+};
+const TERMINAL_STATUSES = new Set([
+    "done",
+    "done_by_agent",
+    "failed",
+    "failed_verification",
+    "failed_scope_violation",
+    "failed_policy_violation",
+    "canceled",
+]);
+export async function runTaskLoop(input) {
+    return runTaskLoopWithDeps(input, DEFAULT_DEPS);
+}
+export async function runTaskLoopWithDeps(input, deps) {
+    const normalized = normalizeInput(input);
+    const resolvedRepoPath = guardWorkspacePath(normalized.repo_path, getConfig().workspaceRoot);
+    const routing = resolveAgentRouting(normalized, deps);
+    const selectedAgent = routing.selected_agent;
+    const now = deps.now().toISOString();
+    const lineage = {
+        lineage_id: deps.createLineageId(deps.now()),
+        goal: normalized.goal,
+        repo_path: resolvedRepoPath,
+        created_at: now,
+        updated_at: now,
+        final_status: "blocked",
+        stop_reason: "policy_blocked",
+        next_action: "inspect_lineage",
+        main_task: null,
+        fix_tasks: [],
+        cleanup_tasks: [],
+        direct_sessions: [],
+        rounds: [],
+        warnings: [],
+        errors: [],
+        worktree: {
+            isolation_mode: normalized.isolation_mode,
+            cleanup: normalized.worktree_cleanup,
+            status: normalized.isolation_mode === "worktree" ? "active" : "not_used",
+            requested_base_branch: normalized.worktree_base_branch,
+            next_action: normalized.isolation_mode === "worktree"
+                ? "Review and explicitly merge or discard the worktree after acceptance."
+                : "none",
+        },
+        agent_routing: routing,
+    };
+    const finalize = (finalStatus, stopReason, nextAction, error) => {
+        lineage.final_status = finalStatus;
+        lineage.stop_reason = stopReason;
+        lineage.next_action = nextAction;
+        lineage.updated_at = deps.now().toISOString();
+        if (error)
+            lineage.errors.push(error);
+        const safe = deps.writeTaskLineage(lineage);
+        return {
+            ...safe,
+            created_task_count: [lineage.main_task, ...lineage.fix_tasks, ...lineage.cleanup_tasks].filter(Boolean).length,
+            auto_fix_tests: normalized.auto_fix_tests,
+            auto_cleanup_artifacts: normalized.auto_cleanup_artifacts,
+            direct_verify: normalized.direct_verify,
+            isolation_mode: normalized.isolation_mode,
+            worktree: safe.worktree,
+            stopped_before_execution: lineage.main_task === null,
+        };
+    };
+    let taskRepoPath = resolvedRepoPath;
+    if (normalized.isolation_mode === "worktree") {
+        try {
+            const worktree = deps.createWorktree(lineage.lineage_id, "task_loop", resolvedRepoPath);
+            taskRepoPath = worktree.worktreePath;
+            lineage.repo_path = taskRepoPath;
+            lineage.worktree = {
+                isolation_mode: "worktree",
+                worktree_id: worktree.worktreeId,
+                worktree_path: worktree.worktreePath,
+                branch: worktree.branch,
+                requested_base_branch: normalized.worktree_base_branch,
+                cleanup: normalized.worktree_cleanup,
+                status: "active",
+                next_action: "Explicitly inspect and merge_worktree or discard_worktree after reviewing this lineage.",
+            };
+        }
+        catch (err) {
+            lineage.worktree = {
+                isolation_mode: "worktree",
+                cleanup: normalized.worktree_cleanup,
+                requested_base_branch: normalized.worktree_base_branch,
+                status: "failed",
+                next_action: "Fix worktree creation prerequisites or rerun with isolation_mode=current_repo.",
+            };
+            return finalize("blocked", "policy_blocked", "Fix worktree creation prerequisites or rerun without worktree isolation.", err instanceof Error ? err.message : String(err));
+        }
+    }
+    let role = "main";
+    let latestFailurePrompt = normalized.goal;
+    for (let iteration = 1; iteration <= normalized.max_iterations; iteration++) {
+        const assessmentInput = {
+            template: role === "main" ? normalized.template : "fix_tests",
+            goal: role === "main" ? normalized.goal : latestFailurePrompt,
+            repo_path: taskRepoPath,
+            agent: selectedAgent,
+            verify_commands: normalized.verify_commands,
+            timeout_seconds: normalized.task_timeout_seconds,
+            execution_mode: "assess_only",
+        };
+        const assessment = await deps.createTask(assessmentInput);
+        if (assessment.decision === "blocked") {
+            return finalize("blocked", "high_risk_blocked", "Risk assessment blocked task execution.", assessment.reason_codes?.join(", "));
+        }
+        if (assessment.decision === "needs_confirm") {
+            return finalize("blocked", "user_confirmation_required", "Ask the user to confirm the assessment before executing the loop.");
+        }
+        const created = await deps.createTask({
+            execution_mode: "execute",
+            assessment_id: String(assessment.assessment_id || ""),
+        });
+        const taskId = String(created.task_id || "");
+        if (!taskId) {
+            return finalize("failed", "policy_blocked", "create_task returned no task_id.", "create_task returned no task_id");
+        }
+        if (role === "main")
+            lineage.main_task = taskId;
+        else
+            lineage.fix_tasks.push(taskId);
+        const wait = await waitUntilTerminal(taskId, normalized.task_timeout_seconds, deps);
+        if (wait.stop_reason) {
+            return finalize("blocked", wait.stop_reason, wait.next_action, wait.error);
+        }
+        const result = deps.safeResult(taskId, { max_items: 8 });
+        const tests = deps.safeTestSummary(taskId);
+        const audit = deps.safeAudit(taskId, { max_items: 8 });
+        const round = buildRound(iteration, taskId, role, result, tests, audit);
+        lineage.rounds.push(round);
+        lineage.updated_at = deps.now().toISOString();
+        if (isSuccessfulRound(round)) {
+            if (normalized.direct_verify) {
+                const direct = await runDirectVerification(lineage.lineage_id, normalized, taskRepoPath, deps);
+                lineage.direct_sessions.push(direct.evidence);
+                if (direct.warning)
+                    lineage.warnings.push(direct.warning);
+                if (direct.stop_reason) {
+                    return finalize(direct.final_status, direct.stop_reason, direct.next_action, direct.error);
+                }
+            }
+            return finalize("accepted", "success", "accept");
+        }
+        if (isHardStop(round, result, audit, normalized.stop_on_high_risk)) {
+            return finalize("blocked", hardStopReason(round, result), round.next_action || "review_task");
+        }
+        latestFailurePrompt = buildFixGoal(normalized.goal, result, round);
+        if (!normalized.auto_fix_tests || round.status !== "failed_verification") {
+            return finalize("needs_fix", "verification_failed", round.next_action || "create_followup_task");
+        }
+        role = "fix_tests";
+    }
+    return finalize("needs_fix", "max_iterations_reached", "review_lineage_and_create_manual_followup");
+}
+async function waitUntilTerminal(taskId, timeoutSeconds, deps) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
+        const waited = await deps.waitForTask(taskId, 30);
+        if (waited.terminal || TERMINAL_STATUSES.has(String(waited.status))) {
+            return { next_action: waited.next_action || "safe_audit" };
+        }
+        if (waited.next_tool_call?.name === "health_check" || waited.continuation_required === false) {
+            return {
+                stop_reason: "watcher_blocked",
+                next_action: waited.next_action || "health_check",
+                error: waited.progress_summary?.hint || "Watcher is blocked or unavailable.",
+            };
+        }
+        await deps.sleep(250);
+    }
+    return {
+        stop_reason: "agent_timeout",
+        next_action: "inspect_task_status",
+        error: `Task loop timed out waiting for ${taskId}.`,
+    };
+}
+function buildRound(iteration, taskId, role, result, tests, audit) {
+    const failChecks = Array.isArray(audit.fail_checks) ? audit.fail_checks.map((entry) => String(entry.name || entry)) : [];
+    const warnChecks = Array.isArray(audit.warn_checks) ? audit.warn_checks.map((entry) => String(entry.name || entry)) : [];
+    return {
+        iteration,
+        task_id: taskId,
+        role,
+        status: String(result.status || "unknown"),
+        terminal: Boolean(result.terminal),
+        verification_status: String(tests.status || result.verification?.status || "not_available"),
+        audit_verdict: String(audit.verdict || audit.acceptance?.verdict || "unknown"),
+        fail_checks: failChecks,
+        warn_checks: warnChecks,
+        next_action: String(result.next_action || audit.recommended_next_actions?.[0] || "review_task"),
+    };
+}
+function isSuccessfulRound(round) {
+    return (round.terminal &&
+        ["done_by_agent", "done", "accepted"].includes(round.status) &&
+        round.verification_status === "passed" &&
+        round.fail_checks.length === 0 &&
+        round.warn_checks.length === 0 &&
+        round.audit_verdict === "pass");
+}
+function isHardStop(round, result, audit, stopOnHighRisk) {
+    if (["failed_scope_violation", "failed_policy_violation", "canceled"].includes(round.status))
+        return true;
+    if (!stopOnHighRisk)
+        return false;
+    const checkNames = [...round.fail_checks, ...round.warn_checks].join(" ").toLowerCase();
+    const reason = String(result.failure_reason || audit.acceptance?.reason || "").toLowerCase();
+    return /scope|secret|sensitive|publish|release|policy|push/.test(`${checkNames} ${reason}`);
+}
+function hardStopReason(round, result) {
+    if (round.status === "failed_scope_violation" || round.status === "failed_policy_violation")
+        return "policy_blocked";
+    if (String(result.failure_reason || "").toLowerCase().includes("timeout"))
+        return "agent_timeout";
+    return "high_risk_blocked";
+}
+function buildFixGoal(originalGoal, result, round) {
+    const failedCommand = result.failed_command ? ` Failed command: ${result.failed_command}.` : "";
+    return [
+        `Fix the failing verification for this PatchWarden loop without changing unrelated behavior.`,
+        `Original goal: ${originalGoal}`,
+        `Previous task: ${round.task_id}. Status: ${round.status}. Verification: ${round.verification_status}.${failedCommand}`,
+        "Do not commit, push, publish, weaken tests, or touch files outside the resolved repository path.",
+    ].join("\n");
+}
+function resolveAgentRouting(normalized, deps) {
+    if (normalized.agent && normalized.agent !== "auto") {
+        return {
+            requested_agent: normalized.agent,
+            selected_agent: normalized.agent,
+            reason: "explicit agent supplied",
+            fallback: false,
+        };
+    }
+    const recommendation = deps.recommendAgentForTask({
+        repo_path: normalized.repo_path,
+        goal: normalized.goal,
+        scope_files: normalized.scope_files,
+        template: normalized.template,
+    });
+    return {
+        requested_agent: normalized.agent || null,
+        selected_agent: recommendation.recommended_agent,
+        reason: recommendation.reason,
+        fallback: recommendation.fallback,
+    };
+}
+async function runDirectVerification(lineageId, normalized, repoPath, deps) {
+    const config = getConfig();
+    if (config.enableDirectProfile !== true) {
+        return {
+            evidence: {
+                session_id: "not_created",
+                status: "skipped",
+                audit_decision: "not_run",
+                next_action: "Enable Direct profile locally before requesting direct_verify.",
+            },
+            stop_reason: "direct_profile_disabled",
+            final_status: "blocked",
+            next_action: "Enable enableDirectProfile locally or rerun run_task_loop with direct_verify=false.",
+            error: "Direct profile is disabled by local config.",
+        };
+    }
+    let sessionId = "";
+    try {
+        const session = await deps.createDirectSession({
+            repo_path: repoPath,
+            title: `Direct verification for ${lineageId}`,
+        });
+        sessionId = session.session_id;
+        const bundle = await deps.runDirectVerificationBundle({
+            session_id: sessionId,
+            commands: normalized.direct_verify_commands,
+            timeout_seconds: normalized.direct_verify_timeout_seconds,
+        });
+        const finalized = await deps.safeFinalizeDirectSession(sessionId, { max_items: 8 });
+        const audit = deps.safeAuditDirectSession(sessionId, { max_items: 8 });
+        const evidence = {
+            session_id: sessionId,
+            status: bundle.status,
+            command_count: bundle.command_count,
+            passed_commands: bundle.passed_commands,
+            failed_commands: bundle.failed_commands,
+            timed_out_commands: bundle.timed_out_commands,
+            audit_decision: audit.decision || "not_run",
+            changed_files_total: Number(finalized.changed_files_total || audit.evidence?.changed_files_total || 0),
+            next_action: String(audit.next_action || bundle.next_action || "review_direct_session"),
+        };
+        if (bundle.status !== "passed") {
+            return {
+                evidence,
+                stop_reason: "direct_verification_failed",
+                final_status: "needs_fix",
+                next_action: "Review Direct verification summary and create a normal follow-up task.",
+                error: "Direct verification failed.",
+            };
+        }
+        if (audit.decision === "fail") {
+            return {
+                evidence,
+                stop_reason: "direct_audit_failed",
+                final_status: "blocked",
+                next_action: "Review Direct audit findings before accepting the loop.",
+                error: "Direct audit failed.",
+            };
+        }
+        return {
+            evidence,
+            final_status: "accepted",
+            next_action: "accept",
+            warning: audit.decision === "warn" ? "Direct audit completed with warnings." : undefined,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            evidence: {
+                session_id: sessionId || "not_created",
+                status: "failed",
+                audit_decision: "not_run",
+                next_action: "Review Direct verification configuration and command allow-list.",
+            },
+            stop_reason: "direct_verification_failed",
+            final_status: "needs_fix",
+            next_action: "Review Direct verification configuration and command allow-list.",
+            error: message,
+        };
+    }
+}
+function normalizeInput(input) {
+    const config = getConfig();
+    const repoPath = String(input.repo_path || "").trim();
+    const goal = String(input.goal || "").trim();
+    if (!repoPath)
+        throw new Error("repo_path is required.");
+    if (!goal)
+        throw new Error("goal is required.");
+    if (!Array.isArray(input.verify_commands) || input.verify_commands.length === 0) {
+        throw new Error("verify_commands must contain at least one command.");
+    }
+    const maxIterations = input.max_iterations ?? 3;
+    if (!Number.isInteger(maxIterations) || maxIterations < 1 || maxIterations > 5) {
+        throw new Error("max_iterations must be an integer from 1 to 5.");
+    }
+    const timeoutSeconds = input.task_timeout_seconds ?? config.defaultTaskTimeoutSeconds;
+    if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 1 || timeoutSeconds > config.maxTaskTimeoutSeconds) {
+        throw new Error(`task_timeout_seconds must be an integer from 1 to ${config.maxTaskTimeoutSeconds}.`);
+    }
+    const template = input.template || "feature_small";
+    if (template !== "inspect_only" && template !== "feature_small" && template !== "release_check") {
+        throw new Error('template must be "inspect_only", "feature_small", or "release_check".');
+    }
+    const directVerifyCommands = Array.isArray(input.direct_verify_commands) && input.direct_verify_commands.length > 0
+        ? input.direct_verify_commands
+        : input.verify_commands;
+    if (input.direct_verify === true && (!Array.isArray(directVerifyCommands) || directVerifyCommands.length === 0)) {
+        throw new Error("direct_verify_commands must contain at least one command when provided.");
+    }
+    const directVerifyTimeout = input.direct_verify_timeout_seconds ?? 120;
+    const maxDirectTimeout = Math.min(config.maxTaskTimeoutSeconds, config.directSessionTtlSeconds);
+    if (!Number.isInteger(directVerifyTimeout) || directVerifyTimeout < 1 || directVerifyTimeout > maxDirectTimeout) {
+        throw new Error(`direct_verify_timeout_seconds must be an integer from 1 to ${maxDirectTimeout}.`);
+    }
+    return {
+        repo_path: repoPath,
+        goal,
+        verify_commands: input.verify_commands.map((command) => String(command).trim()),
+        agent: input.agent ? String(input.agent) : undefined,
+        template,
+        max_iterations: maxIterations,
+        task_timeout_seconds: timeoutSeconds,
+        auto_fix_tests: input.auto_fix_tests !== false,
+        auto_cleanup_artifacts: input.auto_cleanup_artifacts !== false,
+        stop_on_high_risk: input.stop_on_high_risk !== false,
+        direct_verify: input.direct_verify === true,
+        direct_verify_commands: directVerifyCommands.map((command) => String(command).trim()),
+        direct_verify_timeout_seconds: directVerifyTimeout,
+        scope_files: Array.isArray(input.scope_files)
+            ? input.scope_files.map((entry) => String(entry).trim()).filter(Boolean).slice(0, 50)
+            : undefined,
+        isolation_mode: input.isolation_mode === "worktree" ? "worktree" : "current_repo",
+        worktree_base_branch: input.worktree_base_branch ? String(input.worktree_base_branch).trim().slice(0, 160) : undefined,
+        worktree_cleanup: input.worktree_cleanup === "archive" || input.worktree_cleanup === "delete_ignored_only"
+            ? input.worktree_cleanup
+            : "keep",
+    };
+}

package/dist/tools/runVerification.d.ts

@@ -8,6 +8,10 @@ export interface RunVerificationOutput {
     exit_code: number | null;
     passed: boolean;
     timed_out: boolean;
+    redacted: boolean;
+    redaction_categories: string[];
+    started_at: string;
+    finished_at: string;
     stdout_tail: string;
     stderr_tail: string;
     log_path: string;

package/dist/tools/runVerification.js

@@ -22,6 +22,10 @@ export async function runVerification(input) {
         exit_code: result.run.exit_code,
         passed: result.run.passed,
         timed_out: result.run.timed_out,
+        redacted: Boolean(result.run.redacted),
+        redaction_categories: result.run.redaction_categories || [],
+        started_at: result.run.started_at,
+        finished_at: result.run.finished_at,
         stdout_tail: result.run.stdout_tail,
         stderr_tail: result.run.stderr_tail,
         log_path: result.run.log_path,

package/dist/tools/safeViews.d.ts

@@ -162,13 +162,15 @@ export declare function safeDirectSummary(sessionId: string, options?: SafeViewO
         exit_code: number | null;
         passed: boolean;
         timed_out: boolean;
+        redacted: boolean;
+        redaction_categories: string[];
         started_at: string;
         finished_at: string;
     }[];
     large_diff_omitted: boolean;
     truncated: boolean;
 };
-export declare function safeFinalizeDirectSession(sessionId: string, options?: SafeViewOptions): {
+export declare function safeFinalizeDirectSession(sessionId: string, options?: SafeViewOptions): Promise<{
     finalized: boolean;
     next_action: string;
     view: "summary" | "finalize";
@@ -226,12 +228,14 @@ export declare function safeFinalizeDirectSession(sessionId: string, options?: S
         exit_code: number | null;
         passed: boolean;
         timed_out: boolean;
+        redacted: boolean;
+        redaction_categories: string[];
         started_at: string;
         finished_at: string;
     }[];
     large_diff_omitted: boolean;
     truncated: boolean;
-};
+}>;
 export declare function safeAuditDirectSession(sessionId: string, options?: SafeViewOptions): {
     session_id: string;
     decision: "pass" | "warn" | "fail";
@@ -245,6 +249,8 @@ export declare function safeAuditDirectSession(sessionId: string, options?: Safe
             exit_code: number | null;
             passed: boolean;
             timed_out: boolean;
+            redacted: boolean;
+            redaction_categories: string[];
             started_at: string;
             finished_at: string;
         }[];

package/dist/tools/safeViews.js

@@ -92,9 +92,9 @@ export function safeDirectSummary(sessionId, options = {}) {
     const session = readDirectSession(sessionId);
     return directSessionToSafe(session, maxItems, "summary");
 }
-export function safeFinalizeDirectSession(sessionId, options = {}) {
+export async function safeFinalizeDirectSession(sessionId, options = {}) {
     const maxItems = normalizeMaxItems(options.max_items);
-    const finalized = finalizeDirectSession({ session_id: sessionId });
+    const finalized = await finalizeDirectSession({ session_id: sessionId });
     const session = readDirectSession(sessionId);
     return redact({
         ...directSessionToSafe(session, maxItems, "finalize"),
@@ -193,6 +193,8 @@ function summarizeVerificationRuns(runs) {
         exit_code: run.exit_code,
         passed: run.passed,
         timed_out: run.timed_out,
+        redacted: Boolean(run.redacted),
+        redaction_categories: run.redaction_categories || [],
         started_at: run.started_at,
         finished_at: run.finished_at,
     }));

package/dist/tools/taskLineage.d.ts

@@ -0,0 +1,91 @@
+export type TaskLoopStopReason = "success" | "max_iterations_reached" | "verification_failed" | "high_risk_blocked" | "user_confirmation_required" | "agent_timeout" | "policy_blocked" | "watcher_blocked" | "direct_profile_disabled" | "direct_verification_failed" | "direct_audit_failed";
+export interface TaskLineageDirectSession {
+    session_id: string;
+    status?: "passed" | "failed" | "skipped";
+    command_count?: number;
+    passed_commands?: number;
+    failed_commands?: number;
+    timed_out_commands?: number;
+    audit_decision?: "pass" | "warn" | "fail" | "not_run";
+    changed_files_total?: number;
+    next_action?: string;
+}
+export interface TaskLineageWorktree {
+    isolation_mode: "current_repo" | "worktree";
+    worktree_id?: string;
+    worktree_path?: string;
+    branch?: string;
+    requested_base_branch?: string;
+    cleanup: "keep" | "archive" | "delete_ignored_only";
+    status: "not_used" | "active" | "failed";
+    next_action: string;
+}
+export interface TaskLineageAgentRouting {
+    requested_agent: string | null;
+    selected_agent: string;
+    reason: string;
+    fallback: boolean;
+}
+export interface TaskLineageRound {
+    iteration: number;
+    task_id: string;
+    role: "main" | "fix_tests" | "cleanup";
+    status: string;
+    terminal: boolean;
+    verification_status: string;
+    audit_verdict: string;
+    fail_checks: string[];
+    warn_checks: string[];
+    next_action: string;
+}
+export interface TaskLineageRecord {
+    lineage_id: string;
+    goal: string;
+    repo_path: string;
+    created_at: string;
+    updated_at: string;
+    final_status: "accepted" | "needs_fix" | "blocked" | "failed";
+    stop_reason: TaskLoopStopReason;
+    next_action: string;
+    main_task: string | null;
+    fix_tasks: string[];
+    cleanup_tasks: string[];
+    direct_sessions: Array<string | TaskLineageDirectSession>;
+    rounds: TaskLineageRound[];
+    warnings: string[];
+    errors: string[];
+    worktree?: TaskLineageWorktree;
+    agent_routing?: TaskLineageAgentRouting;
+}
+export interface SafeTaskLineage {
+    lineage_id: string;
+    goal: string;
+    repo_path: string;
+    created_at: string;
+    updated_at: string;
+    final_status: TaskLineageRecord["final_status"];
+    stop_reason: TaskLoopStopReason;
+    next_action: string;
+    tasks: {
+        main: string | null;
+        fix: string[];
+        cleanup: string[];
+        direct_sessions: TaskLineageDirectSession[];
+    };
+    worktree: TaskLineageWorktree;
+    agent_routing: TaskLineageAgentRouting | null;
+    verification: {
+        latest_status: string;
+        passed: boolean;
+    };
+    rounds: TaskLineageRound[];
+    warnings: string[];
+    errors: string[];
+    truncated: boolean;
+}
+export declare function createLineageId(now?: Date): string;
+export declare function writeTaskLineage(record: TaskLineageRecord): SafeTaskLineage;
+export declare function getTaskLineage(lineageId: string, options?: {
+    max_items?: number;
+}): SafeTaskLineage;
+export declare function toSafeTaskLineage(record: TaskLineageRecord, maxItems?: number): SafeTaskLineage;