@hhuangpanda/dsh-automation 0.0.0-stage → 0.3.34

package/lib/index.js

@@ -0,0 +1,92 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { AutomationStore } from './store.js';
+import { AutomationDomain } from './domain.js';
+import { AutomationScheduler, DEFAULT_MAX_RUN_DURATION_MS, MAX_TIMER_DELAY_MS } from './scheduler.js';
+import { DshAutomationRunner } from './runner.js';
+import { AutomationController, validatePersistedSessionTarget } from './controller.js';
+import { registerAutomationTools } from './tools.js';
+import { registerAutomationApi } from './api.js';
+import { AgentConfiguration } from './agent-configuration.js';
+import { deliveryOptions, sendAutomationResult, validateDelivery } from './im-delivery.js';
+import '@deepseek-ai/dsh-agent-preset-registry';
+import '@deepseek-ai/dsh-host-webserver';
+import '@deepseek-ai/dsh-llm';
+import '@deepseek-ai/dsh-permission-presets';
+import '@deepseek-ai/dsh-session-title';
+import '@deepseek-ai/dsh-workspace';
+import '@deepseek-ai/dsh-skill';
+export * from './types.js';
+export * from './errors.js';
+export * from './recurrence.js';
+export * from './store.js';
+export * from './domain.js';
+export * from './scheduler.js';
+export * from './controller.js';
+export const name = 'automation';
+export const inject = [
+    'agents',
+    'sessions',
+    'tools',
+    'agentPresets',
+    'llm',
+    'skills',
+    'permissionPresets',
+    'workspaceRegistry',
+    'sessionTitle',
+    'webServer',
+    'connection',
+];
+export async function apply(ctx, config = {}) {
+    const root = resolve(config.root ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'automation'));
+    const maxRunDurationMs = config.maxRunDurationMs ?? DEFAULT_MAX_RUN_DURATION_MS;
+    if (!Number.isSafeInteger(maxRunDurationMs) || maxRunDurationMs <= 0 || maxRunDurationMs > MAX_TIMER_DELAY_MS) {
+        throw new Error(`maxRunDurationMs must be an integer between 1 and ${MAX_TIMER_DELAY_MS}.`);
+    }
+    if (ctx.permissionPresets.names.length === 0)
+        throw new Error('The Host exposes no permission presets.');
+    ctx.permissionPresets.resolve(ctx.permissionPresets.defaultPreset);
+    const store = new AutomationStore(join(root, 'state.json'));
+    const domain = new AutomationDomain(store, config.maxRunHistory);
+    await domain.init(Date.now());
+    const agentConfiguration = new AgentConfiguration(ctx);
+    const runner = new DshAutomationRunner(ctx, agentConfiguration);
+    const scheduler = new AutomationScheduler(domain, runner, undefined, (error) => {
+        ctx.logger.error(`automation scheduler failed and will retry: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    }, maxRunDurationMs, (task, run, outcome, signal) => sendAutomationResult(ctx, task, run, outcome, signal));
+    const controller = new AutomationController(domain, scheduler, undefined, agentConfiguration, (task, sessionId) => validatePersistedSessionTarget(ctx, task, sessionId), {
+        options: (botId) => deliveryOptions(ctx, botId),
+        validate: (destination) => validateDelivery(ctx, destination),
+    });
+    const toolCleanups = new Map();
+    const installTools = (agent) => {
+        // Normal resumed sessions remain usable by their human owner. Tool execution
+        // is guarded per automation turn rather than permanently omitting the tools.
+        if (agent.id.startsWith('automation-') || toolCleanups.has(agent))
+            return;
+        const dispose = registerAutomationTools(ctx, agent.ctx, agent, controller);
+        toolCleanups.set(agent, dispose);
+    };
+    for (const agent of ctx.agents.roots())
+        installTools(agent);
+    const stopCreated = ctx.on('agent/created', ({ agent }) => {
+        installTools(agent);
+        return undefined;
+    });
+    const stopDisposed = ctx.on('agent/disposed', ({ agent }) => {
+        toolCleanups.get(agent)?.();
+        toolCleanups.delete(agent);
+    });
+    const stopApi = registerAutomationApi(ctx, controller);
+    scheduler.start();
+    ctx.effect(() => async () => {
+        stopApi();
+        stopCreated();
+        stopDisposed();
+        for (const dispose of toolCleanups.values())
+            dispose();
+        toolCleanups.clear();
+        await scheduler.stop();
+    }, 'automation.lifecycle()');
+}
+//# sourceMappingURL=index.js.map

package/lib/recurrence.d.ts

@@ -0,0 +1,14 @@
+import type { RRule } from 'rrule';
+import type { AutomationSchedule, RecurringSchedule } from './types.js';
+export declare class ScheduleInputError extends Error {
+    readonly code: 'invalid_schedule' | 'invalid_time_zone' | 'not_future';
+    constructor(code: 'invalid_schedule' | 'invalid_time_zone' | 'not_future', message: string);
+}
+export declare function instant(epoch: number): string;
+export declare function validateTimeZone(timeZone: string): string;
+export declare function buildRule(schedule: RecurringSchedule): RRule;
+export declare function validateSchedule(schedule: AutomationSchedule, now: number): AutomationSchedule;
+export declare function nextOccurrence(schedule: AutomationSchedule, after: number): number | undefined;
+export declare function firstOccurrence(schedule: AutomationSchedule): number | undefined;
+export declare function latestDueOccurrence(schedule: AutomationSchedule, floor: number, now: number): number | undefined;
+//# sourceMappingURL=recurrence.d.ts.map

package/lib/recurrence.js

@@ -0,0 +1,203 @@
+import RRulePackage from 'rrule';
+import { ISO_INSTANT, LOCAL_DATE_TIME } from './types.js';
+const { rrulestr } = RRulePackage;
+export class ScheduleInputError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ScheduleInputError';
+    }
+}
+export function instant(epoch) {
+    if (!Number.isFinite(epoch))
+        throw new ScheduleInputError('invalid_schedule', 'Time is not representable.');
+    const value = new Date(epoch).toISOString();
+    if (!ISO_INSTANT.test(value))
+        throw new ScheduleInputError('invalid_schedule', 'Time must use a four-digit UTC year.');
+    return value;
+}
+export function validateTimeZone(timeZone) {
+    if (!timeZone || timeZone.trim() !== timeZone) {
+        throw new ScheduleInputError('invalid_time_zone', 'timeZone must be a non-empty IANA zone without surrounding whitespace.');
+    }
+    try {
+        return new Intl.DateTimeFormat('en-US', { timeZone }).resolvedOptions().timeZone;
+    }
+    catch {
+        throw new ScheduleInputError('invalid_time_zone', `Unknown IANA time zone: ${timeZone}`);
+    }
+}
+function parseLocalDateTime(value) {
+    if (!LOCAL_DATE_TIME.test(value)) {
+        throw new ScheduleInputError('invalid_schedule', 'startAt must use YYYY-MM-DDTHH:mm:ss local wall-clock form.');
+    }
+    const [date = '', time = ''] = value.split('T');
+    const [year, month, day] = date.split('-').map(Number);
+    const [hour, minute, second] = time.split(':').map(Number);
+    if (year === undefined || month === undefined || day === undefined || hour === undefined || minute === undefined || second === undefined) {
+        throw new ScheduleInputError('invalid_schedule', 'startAt must use YYYY-MM-DDTHH:mm:ss local wall-clock form.');
+    }
+    const candidate = new Date(0);
+    candidate.setUTCFullYear(year, month - 1, day);
+    candidate.setUTCHours(hour, minute, second, 0);
+    if (candidate.getUTCFullYear() !== year ||
+        candidate.getUTCMonth() + 1 !== month ||
+        candidate.getUTCDate() !== day ||
+        candidate.getUTCHours() !== hour ||
+        candidate.getUTCMinutes() !== minute ||
+        candidate.getUTCSeconds() !== second) {
+        throw new ScheduleInputError('invalid_schedule', 'startAt must be a real local calendar time.');
+    }
+    return { year, month, day, hour, minute, second };
+}
+function normalizeRuleText(value) {
+    const trimmed = value.trim();
+    if (!trimmed || /(?:^|\n)DTSTART[:;]/i.test(trimmed)) {
+        throw new ScheduleInputError('invalid_schedule', 'rrule must contain a rule only; startAt and timeZone are separate fields.');
+    }
+    if (trimmed.includes('\n') || trimmed.includes('\r')) {
+        throw new ScheduleInputError('invalid_schedule', 'rrule must be a single RRULE line.');
+    }
+    return trimmed.replace(/^RRULE:/i, '');
+}
+function floatingDate(parts) {
+    return new Date(Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second));
+}
+function localPartsAt(epoch, timeZone) {
+    const formatter = new Intl.DateTimeFormat('en-US-u-ca-iso8601-nu-latn', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hourCycle: 'h23',
+    });
+    const values = Object.fromEntries(formatter.formatToParts(new Date(epoch)).map((part) => [part.type, part.value]));
+    return {
+        year: Number(values.year),
+        month: Number(values.month),
+        day: Number(values.day),
+        hour: Number(values.hour),
+        minute: Number(values.minute),
+        second: Number(values.second),
+    };
+}
+function offsetAt(epoch, timeZone) {
+    const parts = localPartsAt(epoch, timeZone);
+    return floatingDate(parts).getTime() - epoch;
+}
+function equalParts(left, right) {
+    return left.year === right.year && left.month === right.month && left.day === right.day &&
+        left.hour === right.hour && left.minute === right.minute && left.second === right.second;
+}
+/** Resolve one wall-clock occurrence. Gaps are skipped; overlaps choose the earlier instant. */
+function resolveLocalOccurrence(date, timeZone) {
+    const parts = {
+        year: date.getUTCFullYear(),
+        month: date.getUTCMonth() + 1,
+        day: date.getUTCDate(),
+        hour: date.getUTCHours(),
+        minute: date.getUTCMinutes(),
+        second: date.getUTCSeconds(),
+    };
+    const localEpoch = date.getTime();
+    const offsets = new Set([
+        offsetAt(localEpoch - 172_800_000, timeZone),
+        offsetAt(localEpoch, timeZone),
+        offsetAt(localEpoch + 172_800_000, timeZone),
+    ]);
+    const candidates = [...offsets]
+        .map((offset) => localEpoch - offset)
+        .filter((candidate) => equalParts(localPartsAt(candidate, timeZone), parts))
+        .sort((a, b) => a - b);
+    return candidates[0];
+}
+function floatingNow(epoch, timeZone) {
+    return floatingDate(localPartsAt(epoch, timeZone));
+}
+export function buildRule(schedule) {
+    const start = parseLocalDateTime(schedule.startAt);
+    validateTimeZone(schedule.timeZone);
+    const text = `DTSTART:${floatingDate(start).toISOString().replaceAll('-', '').replaceAll(':', '').replace('.000', '')}\nRRULE:${normalizeRuleText(schedule.rrule)}`;
+    try {
+        const parsed = rrulestr(text, { forceset: false });
+        if (!('after' in parsed) || !('before' in parsed))
+            throw new Error('RRULE sets are not supported');
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof ScheduleInputError)
+            throw error;
+        throw new ScheduleInputError('invalid_schedule', `Invalid RRULE: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function validateSchedule(schedule, now) {
+    if (schedule.kind === 'once') {
+        const epoch = Date.parse(schedule.fireAt);
+        if (!ISO_INSTANT.test(schedule.fireAt) || !Number.isFinite(epoch) || new Date(epoch).toISOString() !== schedule.fireAt) {
+            throw new ScheduleInputError('invalid_schedule', 'fireAt must be a canonical RFC 3339 UTC instant.');
+        }
+        if (epoch <= now)
+            throw new ScheduleInputError('not_future', 'fireAt must be strictly in the future.');
+        return schedule;
+    }
+    buildRule(schedule);
+    return {
+        ...schedule,
+        rrule: normalizeRuleText(schedule.rrule),
+        timeZone: validateTimeZone(schedule.timeZone),
+    };
+}
+function nextRecurring(schedule, after) {
+    const rule = buildRule(schedule);
+    let floating = rule.after(floatingNow(after, schedule.timeZone), false);
+    for (let attempts = 0; floating !== null && attempts < 10_000; attempts += 1) {
+        const resolved = resolveLocalOccurrence(floating, schedule.timeZone);
+        if (resolved !== undefined && resolved > after)
+            return resolved;
+        floating = rule.after(floating, false);
+    }
+    return undefined;
+}
+export function nextOccurrence(schedule, after) {
+    if (schedule.kind === 'once') {
+        const target = Date.parse(schedule.fireAt);
+        return target > after ? target : undefined;
+    }
+    return nextRecurring(schedule, after);
+}
+export function firstOccurrence(schedule) {
+    if (schedule.kind === 'once')
+        return Date.parse(schedule.fireAt);
+    const start = floatingDate(parseLocalDateTime(schedule.startAt)).getTime();
+    const rule = buildRule(schedule);
+    let floating = rule.after(new Date(start - 1), false);
+    for (let attempts = 0; floating !== null && attempts < 10_000; attempts += 1) {
+        const resolved = resolveLocalOccurrence(floating, schedule.timeZone);
+        if (resolved !== undefined)
+            return resolved;
+        floating = rule.after(floating, false);
+    }
+    return undefined;
+}
+export function latestDueOccurrence(schedule, floor, now) {
+    if (floor > now)
+        return undefined;
+    if (schedule.kind === 'once') {
+        const target = Date.parse(schedule.fireAt);
+        return target >= floor && target <= now ? target : undefined;
+    }
+    const rule = buildRule(schedule);
+    let floating = rule.before(floatingNow(now, schedule.timeZone), true);
+    for (let attempts = 0; floating !== null && attempts < 10_000; attempts += 1) {
+        const resolved = resolveLocalOccurrence(floating, schedule.timeZone);
+        if (resolved !== undefined && resolved <= now)
+            return resolved >= floor ? resolved : undefined;
+        floating = rule.before(floating, false);
+    }
+    return undefined;
+}
+//# sourceMappingURL=recurrence.js.map

package/lib/runner.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { AutomationRun, AutomationTask } from './types.js';
+import type { AutomationRunner, AutomationRunnerResult, AutomationRunCancelReason } from './scheduler.js';
+import { AgentConfiguration } from './agent-configuration.js';
+import '@deepseek-ai/dsh-agent';
+import '@deepseek-ai/dsh-agent-preset-registry';
+import '@deepseek-ai/dsh-permission-presets';
+import '@deepseek-ai/dsh-session-title';
+import '@deepseek-ai/dsh-workspace';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'plugin:automation': {
+            kind: 'plugin:automation';
+        };
+    }
+}
+export declare class DshAutomationRunner implements AutomationRunner {
+    private readonly ctx;
+    private readonly agentConfiguration;
+    private readonly active;
+    constructor(ctx: Context, agentConfiguration?: AgentConfiguration);
+    cancel(runId: string, reason: AutomationRunCancelReason): boolean;
+    /** Follow one identified message, not the lifetime of the whole shared Agent. */
+    private runTurn;
+    run(task: AutomationTask, run: AutomationRun): Promise<AutomationRunnerResult>;
+}
+//# sourceMappingURL=runner.d.ts.map

package/lib/runner.js

@@ -0,0 +1,295 @@
+import { randomUUID } from 'node:crypto';
+import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { WorkspaceId } from '@deepseek-ai/dsh-workspace';
+import { AutomationError } from './errors.js';
+import { AgentConfiguration } from './agent-configuration.js';
+import { unattendedAgents } from './runtime-marker.js';
+import '@deepseek-ai/dsh-agent';
+import '@deepseek-ai/dsh-agent-preset-registry';
+import '@deepseek-ai/dsh-permission-presets';
+import '@deepseek-ai/dsh-session-title';
+import '@deepseek-ai/dsh-workspace';
+const RUN_SUMMARY_MAX_CHARS = 500;
+function assistantText(event) {
+    return event.data.message.content.filter((block) => block.type === 'text').map((block) => block.text).join('\n').trim();
+}
+function assistantSummary(text) {
+    const summary = text.replace(/\s+/g, ' ').trim();
+    if (!summary)
+        return undefined;
+    const characters = [...summary];
+    return characters.length <= RUN_SUMMARY_MAX_CHARS
+        ? summary
+        : `${characters.slice(0, RUN_SUMMARY_MAX_CHARS - 1).join('')}…`;
+}
+function titleFor(task, run) {
+    const time = run.scheduledAt ?? run.enqueuedAt;
+    return `[Automation] ${task.name}${run.trigger === 'manual' ? ' · Manual' : ''} · ${time.slice(0, 16).replace('T', ' ')}`;
+}
+function promptFor(task, run) {
+    return [
+        `This is an unattended DSH Automation run.`,
+        `Automation: ${task.name} (${task.id})`,
+        `Run: ${run.id}`,
+        `Trigger: ${run.trigger}`,
+        ...(run.scheduledAt === undefined ? [] : [`Scheduled occurrence: ${run.scheduledAt}`]),
+        `Permission preset: ${task.security.permissionPreset}. Do not create or modify automations from this run.`,
+        '',
+        task.prompt,
+    ].join('\n');
+}
+export class DshAutomationRunner {
+    ctx;
+    agentConfiguration;
+    active = new Map();
+    constructor(ctx, agentConfiguration = new AgentConfiguration(ctx)) {
+        this.ctx = ctx;
+        this.agentConfiguration = agentConfiguration;
+    }
+    cancel(runId, reason) {
+        const active = this.active.get(runId);
+        if (active === undefined)
+            return false;
+        if (active.cancelReason !== undefined)
+            return true;
+        const cancelPreparation = active.cancelValidation;
+        if (cancelPreparation === undefined && active.cancelTurn === undefined)
+            return false;
+        active.cancelReason = reason;
+        cancelPreparation?.();
+        try {
+            active.cancelTurn?.();
+        }
+        catch {
+            if (cancelPreparation !== undefined)
+                return true;
+            delete active.cancelReason;
+            return false;
+        }
+        return true;
+    }
+    /** Follow one identified message, not the lifetime of the whole shared Agent. */
+    async runTurn(agent, task, run, active, skills) {
+        const message = createUserMessage({
+            content: [{ type: 'text', text: promptFor(task, run) }],
+            source: { kind: 'plugin:automation' },
+        });
+        let turn;
+        let summary;
+        let output;
+        let settled = false;
+        let marked = false;
+        const disposers = [];
+        let resolveCompletion;
+        const completion = new Promise((resolve) => { resolveCompletion = resolve; });
+        const cleanup = () => {
+            delete active.cancelTurn;
+            if (marked) {
+                unattendedAgents.delete(agent);
+                marked = false;
+            }
+            for (const dispose of disposers.splice(0))
+                dispose();
+        };
+        const finish = (status, error) => {
+            if (settled)
+                return;
+            settled = true;
+            // Synchronous turn/end cleanup: the driver may start a human follow-up
+            // before the Promise continuation below gets a chance to run.
+            cleanup();
+            resolveCompletion({ status, sessionId: agent.session.header.id,
+                ...(summary === undefined ? {} : { summary }), ...(output === undefined ? {} : { output }),
+                ...(error === undefined ? {} : { error }) });
+        };
+        try {
+            disposers.push(this.ctx.on('agent/inbox/claimed', (event) => {
+                if (settled || event.agent !== agent || event.message.id !== message.id)
+                    return;
+                turn = event.turn;
+                unattendedAgents.add(agent);
+                marked = true;
+                if (active.cancelReason !== undefined)
+                    agent.cancel({ kind: 'hook', reason: `automation_${active.cancelReason}` }, { keepInbox: true });
+            }));
+            disposers.push(this.ctx.on('agent/inbox/discarded', (event) => {
+                if (event.agent === agent && event.message.id === message.id && turn === undefined) {
+                    finish('failed', 'Automation input was removed before execution.');
+                }
+            }));
+            disposers.push(this.ctx.on('agent/disposed', (event) => {
+                if (event.agent === agent)
+                    finish('failed', 'Automation Agent was disposed before its turn completed.');
+            }));
+            disposers.push(this.ctx.on('session/event', (session, event) => {
+                if (session !== agent.session || turn === undefined)
+                    return;
+                if (event.type === 'assistant/message' && event.data.turn === turn) {
+                    output = assistantText(event) || undefined;
+                    summary = assistantSummary(output ?? '');
+                }
+                if (event.type === 'turn/end' && event.data.turn === turn) {
+                    const reason = event.data.reason;
+                    finish(reason.kind === 'completed' ? 'succeeded' : 'failed', reason.kind === 'completed' ? undefined
+                        : `Automation turn ended with ${reason.kind === 'error' ? reason.error.message : reason.kind}.`);
+                }
+            }));
+            disposers.push(this.ctx.effect(() => () => {
+                if (settled)
+                    return;
+                try {
+                    active.cancelTurn?.();
+                }
+                finally {
+                    finish('failed', 'Automation runner stopped before its turn completed.');
+                }
+            }, 'automation.turn()'));
+            let admitted = false;
+            try {
+                // Public status also reports maintenance as idle. The official maintenance
+                // reservation is the atomic true-idle check; enqueue synchronously under it.
+                await agent.runMaintenance(async () => {
+                    admitted = true;
+                    if (agent.inbox.nextTurn.length > 0 || agent.inbox.nextStep.length > 0 || unattendedAgents.has(agent)) {
+                        throw new AutomationError('target_session_busy', 'target session has pending work.');
+                    }
+                    if (active.cancelReason !== undefined) {
+                        finish('failed', `Automation run canceled before execution: ${active.cancelReason}.`);
+                        return;
+                    }
+                    this.ctx.permissionPresets.set(agent.session, task.security.permissionPreset);
+                    delete active.cancelValidation;
+                    active.cancelTurn = () => {
+                        if (turn === undefined) {
+                            // Never cancel maintenance or discard someone else's queued prompt.
+                            // A claimed notification may already be dispatching. If removal
+                            // loses that race, the claimed listener applies the pending cancel.
+                            if (agent.inbox.remove(message.id))
+                                finish('failed', 'Automation input was canceled before execution.');
+                        }
+                        else {
+                            agent.cancel({ kind: 'hook', reason: `automation_${active.cancelReason}` }, { keepInbox: true });
+                        }
+                    };
+                    for (const skill of skills)
+                        agent.inject(createUserMessage({ content: [{ type: 'text', text: skill.text }], source: skill.source }));
+                    agent.followup(message);
+                });
+            }
+            catch (error) {
+                if (!admitted)
+                    throw new AutomationError('target_session_busy', 'target session has active work or maintenance.');
+                throw error;
+            }
+            return await completion;
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async run(task, run) {
+        const active = {};
+        const configuredTarget = task.execution.target ?? { mode: 'fresh' };
+        const pinned = (run.executionTarget?.mode ?? configuredTarget.mode) === 'pinned-session';
+        const target = pinned && configuredTarget.mode === 'pinned-session'
+            ? { ...configuredTarget, sessionId: run.executionTarget?.sessionId ?? configuredTarget.sessionId }
+            : undefined;
+        if (pinned && target === undefined)
+            throw new AutomationError('target_resume_failed', 'pinned target snapshot is unavailable.');
+        if (pinned && run.sessionId !== undefined && run.sessionId !== target?.sessionId) {
+            throw new AutomationError('target_resume_failed', 'run target snapshot does not match its session id.');
+        }
+        const sessionId = SessionId(target !== undefined ? target.sessionId : (run.sessionId ?? `automation-${randomUUID()}`));
+        let handle;
+        let agent;
+        let keepSessionLive = false;
+        this.active.set(run.id, active);
+        try {
+            const canceledDuringValidation = new Promise((_resolve, reject) => {
+                active.cancelValidation = () => reject(new Error(`Automation run canceled before Agent creation: ${active.cancelReason}.`));
+            });
+            const validationExecution = pinned
+                ? { ...task.execution, agentPreset: undefined, provider: undefined, model: undefined, reasoningEffort: undefined, skills: [] }
+                : task.execution;
+            await Promise.race([
+                this.agentConfiguration.validate(validationExecution, task.security.permissionPreset, { allowLegacyPartialModel: true }),
+                canceledDuringValidation,
+            ]);
+            const workspace = this.ctx.workspaceRegistry.get(WorkspaceId(target?.workspaceId ?? task.execution.workspaceId))
+                ?? (pinned ? undefined : await this.ctx.workspaceRegistry.create(task.execution.cwd));
+            if (workspace === undefined)
+                throw new AutomationError('target_workspace_mismatch', 'target workspace is unavailable.');
+            if (target !== undefined && workspace.path !== target.cwd)
+                throw new AutomationError('target_workspace_mismatch', 'target cwd does not match.');
+            if (pinned) {
+                const persistence = this.ctx.get('sessionPersistence');
+                if (persistence === undefined)
+                    throw new AutomationError('target_session_unavailable', 'persisted session inspection is unavailable.');
+                const snapshot = await persistence.stat(sessionId);
+                if (snapshot === undefined || snapshot.header.id !== sessionId)
+                    throw new AutomationError('target_session_not_found', 'pinned session could not be resolved.');
+                if (snapshot.header.cwd !== target?.cwd)
+                    throw new AutomationError('target_workspace_mismatch', 'target session cwd does not match.');
+                agent = this.ctx.agents.get(sessionId);
+                if (agent === undefined && active.cancelReason === undefined) {
+                    // Bare agents.resume does not restore the Session's preset or model
+                    // selection. Let the same owner used by Web restore and retain it.
+                    const controller = this.ctx.get('sessionController');
+                    if (controller === undefined)
+                        throw new AutomationError('target_session_unavailable', 'Host session controller is unavailable.');
+                    const resolved = await controller.resolveAgent(sessionId);
+                    if ('error' in resolved)
+                        throw new AutomationError('target_resume_failed', resolved.error.message);
+                    agent = resolved.agent;
+                }
+            }
+            else {
+                handle = await this.ctx.agents.create({
+                    sessionId,
+                    meta: { cwd: workspace.path, ...(task.execution.agentPreset === undefined ? {} : { agentPreset: task.execution.agentPreset }) },
+                    agentOptions: {
+                        ...(task.execution.provider === undefined ? {} : { provider: task.execution.provider }),
+                        ...(task.execution.model === undefined ? {} : { model: task.execution.model }),
+                        ...(task.execution.reasoningEffort === undefined ? {} : { reasoningEffort: ReasoningEffortId(task.execution.reasoningEffort) }),
+                    },
+                    setup: async (agentCtx) => { await this.ctx.agentPresets.mount(agentCtx, task.execution.agentPreset); },
+                });
+                agent = handle.agent;
+            }
+            if (active.cancelReason !== undefined) {
+                keepSessionLive = !pinned;
+                return { status: 'failed', sessionId, error: `Automation run canceled before execution: ${active.cancelReason}.` };
+            }
+            if (agent === undefined)
+                throw new AutomationError('target_resume_failed', 'unable to create agent runtime.');
+            if (pinned && agent.session.header.id !== sessionId)
+                throw new AutomationError('target_session_not_found', 'resumed session id does not match target.');
+            if (pinned && agent.session.header.cwd !== target?.cwd)
+                throw new AutomationError('target_workspace_mismatch', 'resumed session cwd does not match.');
+            if (pinned && (agent.status !== 'idle' || unattendedAgents.has(agent)))
+                throw new AutomationError('target_session_busy', 'target session is busy.');
+            const selectedSkills = pinned ? [] : await Promise.race([
+                this.agentConfiguration.loadSelectedSkills(agent, task), canceledDuringValidation,
+            ]);
+            if (!pinned) {
+                this.ctx.sessionTitle.rename(agent.session, titleFor(task, run));
+                await this.ctx.sessions.flush(agent.session);
+                await workspace.attachSession(sessionId);
+            }
+            // Once the session can accept shared input, retiring this run must not
+            // dispose it and abort a queued human turn. Its owning fiber retains it.
+            keepSessionLive = true;
+            const result = await this.runTurn(agent, task, run, active, selectedSkills);
+            await this.ctx.sessions.flush(agent.session);
+            return result;
+        }
+        finally {
+            delete active.cancelValidation;
+            this.active.delete(run.id);
+            if (handle !== undefined && !keepSessionLive)
+                await handle.dispose();
+        }
+    }
+}
+//# sourceMappingURL=runner.js.map

package/lib/runtime-marker.d.ts

@@ -0,0 +1,3 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+export declare const unattendedAgents: WeakSet<Agent>;
+//# sourceMappingURL=runtime-marker.d.ts.map

package/lib/runtime-marker.js

@@ -0,0 +1,2 @@
+export const unattendedAgents = new WeakSet();
+//# sourceMappingURL=runtime-marker.js.map