@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/core/datadog-metrics.js

@@ -0,0 +1,113 @@
+import { createDatadogMetrics, resolveDatadogApiKey, resolveStandardObservabilityTags, } from 'doistbot-datadog-metrics';
+import { logger } from './logging.js';
+const TASK_COMPLETION_METRIC = 'doistbot.task.completion';
+const TASK_DURATION_METRIC = 'doistbot.task.duration_seconds';
+let hasWarnedAboutMissingDatadogApiKey = false;
+const { postDatadogMetric } = createDatadogMetrics({ logger });
+function toTaskMetricBaseModel(model) {
+    switch (model) {
+        case 'deepseek':
+            return 'deepseek';
+        case 'gemini':
+        case 'google':
+            return 'google';
+        case 'grok':
+            return 'grok';
+        case 'zai':
+            return 'zai';
+        case 'openai':
+            return 'openai';
+        case 'none':
+            return 'none';
+    }
+}
+function toTaskMetricModel(model) {
+    const models = Array.isArray(model) ? model : [model];
+    return Array.from(new Set(models.map((entry) => toTaskMetricBaseModel(entry))))
+        .sort()
+        .join('-');
+}
+function normalizeMetricRepository(repository) {
+    const normalized = repository.trim().toLowerCase();
+    return normalized || 'unknown';
+}
+function buildTaskMetricTags({ type, repository, model, outcome, reason, sandboxVariant, }) {
+    const tags = [
+        `type:${type}`,
+        `repo:${normalizeMetricRepository(repository)}`,
+        `model:${model}`,
+        `status:${outcome}`,
+    ];
+    if (sandboxVariant) {
+        tags.push(`sandbox_variant:${sandboxVariant}`);
+    }
+    if (reason) {
+        tags.push(`reason:${reason}`);
+    }
+    for (const standardTag of resolveStandardObservabilityTags()) {
+        tags.push(standardTag);
+    }
+    return tags;
+}
+export async function recordTaskMetrics({ type, repository, model, outcome, durationMs, reason, sandboxVariant, }) {
+    const apiKey = resolveDatadogApiKey();
+    if (!apiKey) {
+        if (!hasWarnedAboutMissingDatadogApiKey) {
+            hasWarnedAboutMissingDatadogApiKey = true;
+            logger.warn('Skipping Datadog task metric: DATADOG_API_KEY is missing', {
+                type,
+                repository: normalizeMetricRepository(repository),
+                model: toTaskMetricModel(model),
+                outcome,
+                ...(sandboxVariant ? { sandboxVariant } : {}),
+                ...(reason ? { reason } : {}),
+            });
+        }
+        return;
+    }
+    const timestamp = Math.floor(Date.now() / 1000);
+    const durationSeconds = Math.max(durationMs, 0) / 1000;
+    const metricModel = toTaskMetricModel(model);
+    const tags = buildTaskMetricTags({
+        type,
+        repository,
+        model: metricModel,
+        outcome,
+        reason,
+        sandboxVariant,
+    });
+    await Promise.allSettled([
+        postDatadogMetric({
+            apiKey,
+            path: '/api/v2/series',
+            body: {
+                series: [
+                    {
+                        metric: TASK_COMPLETION_METRIC,
+                        type: 1,
+                        points: [
+                            {
+                                timestamp,
+                                value: 1,
+                            },
+                        ],
+                        tags,
+                    },
+                ],
+            },
+        }),
+        postDatadogMetric({
+            apiKey,
+            path: '/api/v1/distribution_points',
+            body: {
+                series: [
+                    {
+                        metric: TASK_DURATION_METRIC,
+                        points: [[timestamp, [durationSeconds]]],
+                        tags,
+                    },
+                ],
+            },
+        }),
+    ]);
+}

package/sandbox/dist/core/environment.js

@@ -0,0 +1,49 @@
+export const WORKSPACE_DIR = process.env.WORKSPACE_DIR || '/workspace';
+export const REPOS_SUBDIR = 'repos';
+/**
+ * Parses a required environment variable, throwing if missing.
+ */
+export function requiredEnv(name, env = process.env) {
+    const value = env[name];
+    if (!value) {
+        throw new Error(`Missing required environment variable: ${name}`);
+    }
+    return value;
+}
+/**
+ * Parses a required environment variable as a positive integer.
+ */
+export function requiredPositiveInt(name, env = process.env) {
+    const value = requiredEnv(name, env);
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`Invalid ${name}: expected a positive integer, got "${value}"`);
+    }
+    return parsed;
+}
+/**
+ * Parses an optional string as a positive integer, returning undefined if missing or invalid.
+ */
+export function optionalPositiveInt(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0)
+        return undefined;
+    return parsed;
+}
+/**
+ * Parses the base environment variables common to all sandbox tasks.
+ */
+export function parseBaseContext(env = process.env) {
+    return {
+        owner: requiredEnv('REPO_OWNER', env),
+        repo: requiredEnv('REPO_NAME', env),
+        prNumber: requiredPositiveInt('PR_NUMBER', env),
+        installationId: requiredPositiveInt('INSTALLATION_ID', env),
+        appId: requiredEnv('APP_ID', env),
+        privateKey: requiredEnv('PRIVATE_KEY', env),
+        githubToken: env.GITHUB_TOKEN?.trim() || undefined,
+        deliveryId: env.DELIVERY_ID?.trim() || undefined,
+    };
+}

package/sandbox/dist/core/git-auth.js

@@ -0,0 +1,17 @@
+export const GITHUB_HTTPS_REWRITE_ARGS = [
+    '-c',
+    'url.https://github.com/.insteadOf=git@github.com:',
+    '-c',
+    'url.https://github.com/.insteadOf=ssh://git@github.com/',
+];
+export function gitAuthEnv(token) {
+    const index = Number(process.env.GIT_CONFIG_COUNT ?? 0);
+    const env = { ...process.env };
+    delete env.GIT_SSH_SIGNING_KEY;
+    return {
+        ...env,
+        GIT_CONFIG_COUNT: String(index + 1),
+        [`GIT_CONFIG_KEY_${index}`]: 'http.https://github.com/.extraheader',
+        [`GIT_CONFIG_VALUE_${index}`]: `Authorization: Basic ${Buffer.from(`x-access-token:${token}`).toString('base64')}`,
+    };
+}

package/sandbox/dist/core/github-history.js

@@ -0,0 +1,4 @@
+/** Preserve pre-rename report/checkpoint identities. Never use this for API authorization. */
+export function githubHistoryIdentity(value) {
+    return value.replace(/^(https:\/\/github\.com\/)?todoist\//i, '$1Doist/');
+}

package/sandbox/dist/core/github-issues.js

@@ -0,0 +1,18 @@
+export async function fetchIssue(octokit, { owner, repo, issueNumber, mediaType }) {
+    const response = await octokit.rest.issues.get({
+        owner,
+        repo,
+        issue_number: issueNumber,
+        ...(mediaType && { mediaType }),
+    });
+    return response.data;
+}
+export async function fetchIssueComments(octokit, { owner, repo, issueNumber, mediaType }) {
+    return (await octokit.paginate(octokit.rest.issues.listComments, {
+        owner,
+        repo,
+        issue_number: issueNumber,
+        per_page: 100,
+        ...(mediaType && { mediaType }),
+    }));
+}

package/sandbox/dist/core/label-parsing.js

@@ -0,0 +1 @@
+export { extractScopedLabelValues, normalizeScopedLabelValue, scopedLabelValue, } from 'doistbot-issue-routing';

package/sandbox/dist/core/langfuse-observation.js

@@ -0,0 +1,33 @@
+import { context, SpanStatusCode, trace } from '@opentelemetry/api';
+import { SANDBOX_TRACER_NAME } from './tracing.js';
+import { isLangfuseTracingEnabled } from './tracing-setup.js';
+// Cap prompt/completion payloads well under exporter attribute limits. Review
+// prompts embed full diffs and can reach megabytes.
+const LANGFUSE_IO_MAX_CHARS = 200_000;
+// Opens a Langfuse generation for one model call, as a child of the active
+// span. Each call gets its own span, so a call outside a model phase (e.g.
+// conversation summarization under the task root) or a retry inside one never
+// overwrites another span. The span is not made active, so tool spans keep
+// their phase parent, and the LoggerSpanProcessor skips it, so Datadog log
+// lines keep their shape. Returns undefined when Langfuse is disabled.
+export function startGeneration(name, input) {
+    if (!isLangfuseTracingEnabled())
+        return undefined;
+    return trace.getTracer(SANDBOX_TRACER_NAME).startSpan(name, {
+        attributes: {
+            'doistbot.kind': 'generation',
+            'langfuse.observation.type': 'generation',
+            'langfuse.observation.input': input.slice(0, LANGFUSE_IO_MAX_CHARS),
+        },
+    }, context.active());
+}
+export function endGeneration(span, outcome) {
+    if (!span)
+        return;
+    const output = 'output' in outcome ? outcome.output : outcome.error;
+    span.setAttribute('langfuse.observation.output', output.slice(0, LANGFUSE_IO_MAX_CHARS));
+    // The error text is already the output; keep the status message out of it.
+    if ('error' in outcome)
+        span.setStatus({ code: SpanStatusCode.ERROR });
+    span.end();
+}

package/sandbox/dist/core/langfuse-session.js

@@ -0,0 +1,39 @@
+import { propagateAttributes } from '@langfuse/tracing';
+import { context, trace, TraceFlags } from '@opentelemetry/api';
+import { deriveLangfuseTraceId } from 'doistbot-shared-contracts';
+import { isLangfuseTracingEnabled } from './tracing-setup.js';
+export function buildSessionId(env = process.env) {
+    const number = env.PR_NUMBER ?? env.ISSUE_NUMBER;
+    if (!env.REPO_OWNER || !env.REPO_NAME || !number)
+        return undefined;
+    return `${env.REPO_OWNER}/${env.REPO_NAME}#${number}`;
+}
+// Wraps a whole task run so every span inherits the Langfuse sessionId/userId,
+// rooted under a deterministic trace id derived from DELIVERY_ID — the same id
+// the webhook-handler re-derives to attach feedback scores. No-op when Langfuse
+// is disabled, so log/visualizer output is unchanged (their root-span detection
+// relies on parent_span_id being null).
+export async function withLangfuseTaskContext(fn) {
+    if (!isLangfuseTracingEnabled())
+        return fn();
+    let run = fn;
+    const sessionId = buildSessionId();
+    const userId = process.env.ACTOR_LOGIN?.trim() || undefined;
+    if (sessionId || userId) {
+        const inner = run;
+        run = () => propagateAttributes({ ...(sessionId ? { sessionId } : {}), ...(userId ? { userId } : {}) }, inner);
+    }
+    const deliveryId = process.env.DELIVERY_ID?.trim();
+    if (deliveryId) {
+        const traceId = deriveLangfuseTraceId(deliveryId);
+        const parent = trace.setSpanContext(context.active(), {
+            traceId,
+            spanId: traceId.slice(0, 16), // synthetic remote parent, never emitted
+            traceFlags: TraceFlags.SAMPLED,
+            isRemote: true,
+        });
+        const inner = run;
+        run = () => context.with(parent, inner);
+    }
+    return run();
+}

package/sandbox/dist/core/logger-span-processor.js

@@ -0,0 +1,90 @@
+import { SpanStatusCode, trace } from '@opentelemetry/api';
+import { logger } from './logging.js';
+const MAX_ATTR_SERIALIZED_LEN = 4096;
+export function hrTimeToMs(hrTime) {
+    const [seconds, nanos] = hrTime;
+    return Math.round(seconds * 1000 + nanos / 1_000_000);
+}
+function capString(value) {
+    if (value.length <= MAX_ATTR_SERIALIZED_LEN)
+        return value;
+    // Reserve room for the marker so the FINAL emitted value stays <= the cap.
+    const marker = `…[truncated, ${value.length} chars]`;
+    return `${value.slice(0, Math.max(0, MAX_ATTR_SERIALIZED_LEN - marker.length))}${marker}`;
+}
+export function truncateAttrs(attrs) {
+    const out = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        if (key === 'doistbot.kind')
+            continue; // internal marker, never emitted
+        // Langfuse-only payloads (prompt/completion text) — kept out of Datadog.
+        if (key.startsWith('langfuse.'))
+            continue;
+        if (typeof value === 'string') {
+            out[key] = capString(value);
+        }
+        else if (value !== null && typeof value === 'object') {
+            // Arrays/objects (e.g. decision paths, parsed-label arrays): keep
+            // the native value if its JSON serialization is under the cap;
+            // otherwise replace it with the truncated serialized string.
+            const json = JSON.stringify(value);
+            out[key] = json.length > MAX_ATTR_SERIALIZED_LEN ? capString(json) : value;
+        }
+        else {
+            out[key] = value; // number / boolean / null — inherently small
+        }
+    }
+    return out;
+}
+// Parent span id access on a finished span is SDK-version-specific. Prefer the
+// newer `parentSpanContext`, fall back to the older `parentSpanId`. Only used
+// in onEnd — onStart derives the parent from the parent Context instead.
+function parentSpanIdOf(span) {
+    const withParentCtx = span;
+    if (withParentCtx.parentSpanContext?.spanId)
+        return withParentCtx.parentSpanContext.spanId;
+    const withParentId = span;
+    return withParentId.parentSpanId ?? null;
+}
+// Generation spans exist only for Langfuse (see startGeneration). Datadog keeps
+// the phase and tool spans it already had.
+function isLangfuseOnly(span) {
+    return span.attributes['doistbot.kind'] === 'generation';
+}
+// Span attributes are spread FIRST so task attributes can never overwrite the
+// envelope fields (event/name/span_id/parent_span_id/duration_ms/status/error)
+// that the Datadog pipeline and the visualizer key on. Timestamps come from
+// the logging system, never from meta.
+export class LoggerSpanProcessor {
+    onStart(span, parentContext) {
+        const readable = span;
+        if (isLangfuseOnly(readable))
+            return;
+        const isTool = readable.attributes['doistbot.kind'] === 'tool';
+        logger.info(`${isTool ? 'tool' : 'phase'}.start: ${readable.name}`, {
+            ...truncateAttrs(readable.attributes),
+            event: isTool ? 'tool.start' : 'phase.start',
+            name: readable.name,
+            span_id: readable.spanContext().spanId,
+            parent_span_id: trace.getSpanContext(parentContext)?.spanId ?? null,
+        });
+    }
+    onEnd(span) {
+        if (isLangfuseOnly(span))
+            return;
+        const isTool = span.attributes['doistbot.kind'] === 'tool';
+        const status = span.status.code === SpanStatusCode.ERROR ? 'error' : 'ok';
+        logger.info(`${isTool ? 'tool' : 'phase'}.end: ${span.name}`, {
+            ...truncateAttrs(span.attributes),
+            event: isTool ? 'tool.end' : 'phase.end',
+            name: span.name,
+            span_id: span.spanContext().spanId,
+            parent_span_id: parentSpanIdOf(span),
+            duration_ms: hrTimeToMs(span.duration),
+            status,
+            ...(status === 'error' && span.status.message ? { error: span.status.message } : {}),
+        });
+    }
+    async forceFlush() { }
+    async shutdown() { }
+}

package/sandbox/dist/core/logging.js

@@ -0,0 +1,18 @@
+import { createLogger } from 'doistbot-logging';
+let suppressedLogLevels = new Set();
+export const logger = createLogger({
+    suppressLogs: (level) => suppressedLogLevels.has(level),
+});
+export async function withLogsSuppressed(logLevels, task) {
+    const previousValue = suppressedLogLevels;
+    suppressedLogLevels = new Set(logLevels);
+    try {
+        return await task();
+    }
+    finally {
+        suppressedLogLevels = previousValue;
+    }
+}
+export async function withInfoLogsSuppressed(suppressInfoLogs, task) {
+    return suppressInfoLogs ? await withLogsSuppressed(['info'], task) : await task();
+}

package/sandbox/dist/core/pi-autofix-extension.js

@@ -0,0 +1,188 @@
+import { execFileSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { Type } from '@earendil-works/pi-ai';
+import { serviceQueryArgs } from './autofix-service-query.js';
+import { isForbiddenAutofixTest } from './autofix-test-policy.js';
+import { AUTOFIX_RUNTIME_ENV, AutofixVerifier, hashAutofixInputs, readAutofixRuntime, summarizeVerification, } from './autofix-verification.js';
+import { boundedToolOutput, safeToolOutput, writeToolRecord } from './tool-output.js';
+// eslint-disable-next-line import/no-default-export
+export default function autofixExtension(pi) {
+    const file = process.env[AUTOFIX_RUNTIME_ENV];
+    if (!file)
+        throw new Error('Missing autofix runtime configuration');
+    const runtime = readAutofixRuntime(file);
+    const cancellation = new AbortController();
+    process.once('SIGTERM', () => {
+        cancellation.abort();
+        setTimeout(() => process.exit(143), 1500).unref();
+    });
+    function git(args) {
+        return execFileSync('git', args, {
+            cwd: runtime.repoPath,
+            encoding: 'utf8',
+            maxBuffer: 5 * 1024 * 1024,
+            env: { ...process.env, GIT_EXTERNAL_DIFF: '', GIT_PAGER: 'cat' },
+            timeout: 10_000,
+        });
+    }
+    function fingerprint() {
+        git(['add', '-A']);
+        return hashAutofixInputs(git(['diff', '--no-ext-diff', '--no-textconv', '--full-index', 'HEAD', '--binary']));
+    }
+    const verifier = new AutofixVerifier(runtime, fingerprint, (result) => {
+        writeToolRecord({ type: 'doistbot_verification_result', ...result });
+    });
+    pi.registerTool({
+        name: 'verify',
+        label: 'Verify fix',
+        description: 'Run checks from the repository autofix policy. The first round runs all configured checks. Later rounds can select named checks. There is no round-count limit; checks must finish within the autofix time limit. Checks run in order. Group repairs before each rerun. Supply testSelectors for the smallest set of relevant existing or new unit tests. The repo commands receive these as DOISTBOT_TEST_SELECTORS, one per line. Unchanged passed checks are reused.',
+        parameters: Type.Object({
+            checks: Type.Array(Type.String(), { minItems: 1, uniqueItems: true }),
+            testSelectors: Type.Optional(Type.Array(Type.String({ pattern: '^[^\\r\\n\\u0000]{1,200}$' }), {
+                maxItems: 30,
+                uniqueItems: true,
+            })),
+        }),
+        async execute(_id, params, signal) {
+            const state = await verifier.verify(params.checks, AbortSignal.any([cancellation.signal, ...(signal ? [signal] : [])]), params.testSelectors);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: summarizeVerification(state, runtime.policy, fingerprint()),
+                    },
+                ],
+                details: {},
+            };
+        },
+    });
+    pi.registerTool({
+        name: 'query_service',
+        label: 'Query evidence',
+        description: 'Read GitHub evidence with gh, Datadog logs with pup, or Sentry reports with sentry. Supply separate CLI arguments. Use --help to read supported syntax. Resolve only a specific gap in the triage plan.',
+        parameters: Type.Object({
+            cli: Type.Union([Type.Literal('gh'), Type.Literal('pup'), Type.Literal('sentry')]),
+            args: Type.Array(Type.String(), { minItems: 1 }),
+        }),
+        async execute(_id, params) {
+            const args = serviceQueryArgs(params.cli, params.args);
+            try {
+                const output = execFileSync(params.cli, args, {
+                    cwd: runtime.repoPath,
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                    env: { ...process.env, GH_HOST: 'github.com' },
+                    maxBuffer: 2 * 1024 * 1024,
+                    timeout: Math.max(1, Math.min(60_000, runtime.deadlineMs - Date.now())),
+                });
+                return {
+                    content: [{ type: 'text', text: safeToolOutput(output).slice(-24_000) }],
+                    details: {},
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: safeToolOutput(error instanceof Error ? error.message : 'Evidence query failed').slice(-8000),
+                        },
+                    ],
+                    details: {},
+                    isError: true,
+                };
+            }
+        },
+    });
+    pi.registerTool({
+        name: 'inspect_git',
+        label: 'Inspect Git',
+        description: 'Read repository status, current diff, or recent commit history.',
+        parameters: Type.Object({
+            view: Type.Union([Type.Literal('status'), Type.Literal('diff'), Type.Literal('log')]),
+        }),
+        async execute(_id, params) {
+            const args = params.view === 'status'
+                ? ['status', '--short']
+                : params.view === 'log'
+                    ? ['log', '-10', '--oneline']
+                    : ['diff', '--no-ext-diff', '--no-textconv', 'HEAD'];
+            return {
+                content: [{ type: 'text', text: boundedToolOutput(safeToolOutput(git(args))) }],
+                details: {},
+            };
+        },
+    });
+    pi.on('tool_call', (event) => {
+        if (event.toolName === 'bash')
+            return { block: true, reason: 'Use verify for approved checks.' };
+        if (event.toolName !== 'edit' && event.toolName !== 'write')
+            return undefined;
+        const inputPath = event.input.path;
+        if (typeof inputPath !== 'string')
+            return { block: true, reason: 'Missing file path' };
+        // Pi rewrites these forms before a write. Require plain paths at this boundary.
+        if (/^[@~]|^file:\/\/|[\u00a0\u2000-\u200a\u202f\u205f\u3000]/.test(inputPath))
+            return { block: true, reason: 'Use a plain relative or absolute file path.' };
+        const fullPath = path.resolve(runtime.repoPath, inputPath);
+        const relative = path.relative(runtime.repoPath, fullPath);
+        if (relative.startsWith('..') ||
+            path.isAbsolute(relative) ||
+            relative === '.git' ||
+            relative.startsWith('.git/')) {
+            return { block: true, reason: 'Only target repository source files can be changed.' };
+        }
+        // Resolve existing ancestors so a repository symlink cannot write outside the checkout.
+        let ancestor = fullPath;
+        while (ancestor !== path.dirname(ancestor)) {
+            try {
+                const resolved = path.relative(realpathSync(runtime.repoPath), path.resolve(realpathSync(ancestor), path.relative(ancestor, fullPath)));
+                if (resolved === '.github/doistbot.yml' ||
+                    resolved === '.git' ||
+                    resolved.startsWith('.git/')) {
+                    return { block: true, reason: 'Autofix cannot change Git files or its policy.' };
+                }
+                if (isForbiddenAutofixTest(resolved, runtime.policy.forbidden_test_paths)) {
+                    return { block: true, reason: 'Autofix cannot change UI tests.' };
+                }
+                if (resolved.startsWith('..') || path.isAbsolute(resolved)) {
+                    return { block: true, reason: 'File resolves outside the target repository.' };
+                }
+                break;
+            }
+            catch {
+                ancestor = path.dirname(ancestor);
+            }
+        }
+        let content = '';
+        if (event.toolName === 'write' && typeof event.input.content === 'string') {
+            content = event.input.content;
+        }
+        else if (event.toolName === 'edit' && Array.isArray(event.input.edits)) {
+            content = event.input.edits
+                .flatMap((edit) => {
+                if (edit &&
+                    typeof edit === 'object' &&
+                    'newText' in edit &&
+                    typeof edit.newText === 'string')
+                    return [edit.newText];
+                return [];
+            })
+                .join('\n');
+        }
+        else if (event.toolName === 'edit' &&
+            'newText' in event.input &&
+            typeof event.input.newText === 'string') {
+            content = event.input.newText;
+        }
+        if (relative === '.github/doistbot.yml' ||
+            isForbiddenAutofixTest(relative, runtime.policy.forbidden_test_paths, content)) {
+            return {
+                block: true,
+                reason: 'Autofix cannot change its policy or create or change UI tests.',
+            };
+        }
+        return undefined;
+    });
+}

package/sandbox/dist/core/pi-execution-limits-extension.js

@@ -0,0 +1,79 @@
+export const PI_EXECUTION_LIMIT_ENV = {
+    startedAtMs: 'DOISTBOT_PI_LIMIT_STARTED_AT_MS',
+    softTimeMs: 'DOISTBOT_PI_SOFT_TIME_LIMIT_MS',
+    softToolCalls: 'DOISTBOT_PI_SOFT_TOOL_LIMIT',
+    hardTimeMs: 'DOISTBOT_PI_HARD_TIME_LIMIT_MS',
+    hardToolCalls: 'DOISTBOT_PI_HARD_TOOL_LIMIT',
+};
+const SOFT_LIMIT_MESSAGE = 'The inspection budget is nearly complete. Stop gathering new context and return the requested final result now using the evidence you already have.';
+const HARD_LIMIT_MESSAGE = 'The inspection budget is complete. Do not request more tools. Return the requested final result immediately using the evidence you already have.';
+const HARD_TOOL_BLOCK_REASON = 'The inspection budget is complete. No more tool calls are available. Return the final result now.';
+function readPositiveInteger(name) {
+    // Keep this parser local. Pi loads this file as a standalone extension, so
+    // importing shared application helpers would also load their dependencies.
+    const parsed = Number(process.env[name]);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+// Pi's extension loader requires a default export.
+// eslint-disable-next-line import/no-default-export
+export default function executionLimitsExtension(pi) {
+    const startedAtMs = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.startedAtMs) ?? Date.now();
+    const softTimeMs = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.softTimeMs);
+    const softToolCalls = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.softToolCalls);
+    const hardTimeMs = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.hardTimeMs);
+    const hardToolCalls = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.hardToolCalls);
+    let timersStarted = false;
+    let softLimitReached = false;
+    let hardLimitReached = false;
+    let toolCallCount = 0;
+    const timers = [];
+    function steer(message) {
+        pi.sendUserMessage(message, { deliverAs: 'steer' });
+    }
+    function reachSoftLimit() {
+        if (softLimitReached)
+            return;
+        softLimitReached = true;
+        steer(SOFT_LIMIT_MESSAGE);
+    }
+    function reachHardLimit() {
+        if (hardLimitReached)
+            return;
+        hardLimitReached = true;
+        softLimitReached = true;
+        steer(HARD_LIMIT_MESSAGE);
+    }
+    function scheduleAtElapsed(elapsedMs, callback) {
+        const remainingMs = Math.max(0, elapsedMs - (Date.now() - startedAtMs));
+        timers.push(setTimeout(callback, remainingMs));
+    }
+    pi.on('agent_start', () => {
+        if (timersStarted)
+            return;
+        timersStarted = true;
+        if (softTimeMs)
+            scheduleAtElapsed(softTimeMs, reachSoftLimit);
+        if (hardTimeMs)
+            scheduleAtElapsed(hardTimeMs, reachHardLimit);
+    });
+    pi.on('tool_call', () => {
+        if (hardLimitReached) {
+            return { block: true, reason: HARD_TOOL_BLOCK_REASON };
+        }
+        toolCallCount += 1;
+        if (softToolCalls && toolCallCount >= softToolCalls) {
+            reachSoftLimit();
+        }
+        if (hardToolCalls && toolCallCount >= hardToolCalls) {
+            // The call that reaches the hard limit is allowed to finish. All
+            // later calls are blocked so the model can submit its current work.
+            reachHardLimit();
+        }
+        return undefined;
+    });
+    pi.on('agent_settled', () => {
+        for (const timer of timers)
+            clearTimeout(timer);
+        timers.length = 0;
+    });
+}