@toddzheng024/dscode-bundle 0.7.26 → 0.7.28

package/vendor/bash/types/background.d.ts

@@ -1,19 +1,50 @@
 /**
- * Generic-task adaptation for background bash process handles.
+ * Generic-job adaptation for bash process handles: the terminal outcome the
+ * registry records, the pull sources it pumps, and the ring read a foreground
+ * call renders when it stops waiting.
  *
  * @module @deepseek-ai/dsh-tool-bash/background
  */
+import type { SandboxMode } from '@deepseek-ai/dsh-sandbox';
 import type { ShellProcess } from '@deepseek-ai/dsh-shell';
+import type { JobChunk, JobHooks, JobOutcome, JobOutputSource } from '@deepseek-ai/dsh-jobs';
 /**
- * Map a settled background process onto the generic task-outcome vocabulary:
+ * Map a settled background process onto the generic job-outcome vocabulary:
  * `killed` stays `killed` (detail: the signal when one is known), everything
  * else is `completed` with the exit code as detail. A nonzero command exit is
- * reported, not failed, exactly like the foreground rendering.
+ * reported, not failed, exactly like the foreground rendering. Sandbox facts
+ * join the detail, since a job's terminal reason is the one line every
+ * reader — the model's status line, the roster row — shows.
  * @param proc - the settled process handle.
+ * @param escalationModes - escalation targets advertised by this composition.
  * @returns the outcome for the `ctx.jobs` registration.
  */
-export declare function processOutcome(proc: ShellProcess): {
-    status: 'completed' | 'killed';
-    detail: string;
-};
+export declare function processOutcome(proc: ShellProcess, escalationModes?: readonly SandboxMode[]): JobOutcome;
+/**
+ * The process's non-consuming stream readers as registry pull sources. They
+ * bind lazily because the process is spawned inside the starter, after the
+ * registry admitted the job; a read before the spawn yields nothing, and the
+ * pump keeps the model's consuming cursor untouched. A rejected spawn's
+ * stderr reader carries the provider's `subprocess failed before reporting an
+ * outcome: …` note.
+ * @param proc - the started process's observed streams, once the starter has spawned it.
+ * @returns one source per stream, stdout first.
+ */
+export declare function processSources(proc: () => Pick<ShellProcess, 'observed'> | undefined): JobOutputSource[];
+/**
+ * The ring chunks of one consuming registry read as the shell tools render a
+ * process read: stdout chunks in order, then every stderr chunk in one
+ * `[stderr]` section, so the output a foreground call hands over when it
+ * stops waiting reads exactly like the `job_output` reads that follow it.
+ * @param chunks - the chunks since the model cursor, in offset order.
+ * @returns the delta text, possibly empty.
+ */
+export declare function ringDelta(chunks: readonly JobChunk[]): string;
+/**
+ * Adapt asynchronous shell preparation after job admission without exposing a partial process.
+ * @param start - starts the process with job-owned cancellation.
+ * @param outcome - projects the settled process into the job outcome.
+ * @returns synchronous job hooks whose completion includes preparation and process settlement.
+ */
+export declare function processJob(start: (signal: AbortSignal) => Promise<ShellProcess>, outcome: (process: ShellProcess) => JobOutcome): JobHooks;
 //# sourceMappingURL=background.d.ts.map

package/vendor/bash/types/index.d.ts

@@ -1,7 +1,10 @@
 /**
- * Model-facing Consumer of the `ctx.shell` capability seam. Background calls
- * register process handles with `ctx.jobs`; their work uses job cancellation
- * rather than the tool-call signal after an id is returned.
+ * Model-facing Consumer of the `ctx.shell` capability seam. While a job
+ * registry is composed, every call registers its process with `ctx.jobs` as
+ * it starts: `run_in_background` returns the id at once, and a foreground call
+ * waits on its job until the command finishes or the wait times out, at which
+ * point it returns the same id. Without a registry the tool is foreground-only
+ * and the executor's deadline kills the command.
  *
  * TODO(permissions): deployment policy belongs in `tools/pre-execute` and
  * sandboxing executors; see docs/architecture.md § Where new behavior goes.
@@ -13,8 +16,21 @@ export declare const name = "tool-bash";
 export declare const inject: string[];
 /** Configuration for the bash tool. */
 export interface Config {
-    /** Expose `run_in_background` (default true); disabled calls are also rejected. */
+    /**
+     * Expose `run_in_background` while a job registry is composed (default
+     * true); disabled calls are also rejected. Without a registry the tool is
+     * foreground-only regardless.
+     */
     enableRunInBackground?: boolean;
+    /**
+     * Keep a foreground command that reaches its timeout running as a
+     * background job instead of killing it (default true). Applies only while
+     * background execution is available: with `enableRunInBackground` false or
+     * no job registry, the executor's deadline kills the command. A foreground
+     * command the registry refuses at its start (admission or a missing
+     * controller) also runs under the deadline kill.
+     */
+    promoteOnTimeout?: boolean;
 }
 /** Runtime configuration schema for the bash tool plugin. */
 export declare const Config: z<Config>;

package/vendor/bash/types/render.d.ts

@@ -3,7 +3,7 @@
  *
  * @module @deepseek-ai/dsh-tool-bash/render
  */
-import type { ShellProcessRead, ShellRunResult, ShellSandboxInfo } from '@deepseek-ai/dsh-shell';
+import type { ShellRunResult, ShellSandboxInfo } from '@deepseek-ai/dsh-shell';
 import type { SandboxMode } from '@deepseek-ai/dsh-sandbox';
 /**
  * Shape one finished run into the text the model sees: stdout, then a marked
@@ -14,20 +14,39 @@ import type { SandboxMode } from '@deepseek-ai/dsh-sandbox';
  * @param escalationModes - the escalation targets this composition advertises;
  *   non-empty adds the same-turn escalation hint after a denial marker
  *   (default `[]`: no hint).
- * @returns the model-facing text: output body (or `(no output)`), then any timeout/signal/exit markers, each on its own line.
+ * @returns the model-facing text: output body (or `(no output)`), then any timeout/stopped/signal/exit markers, each on its own line.
  */
-export declare function renderResult(result: ShellRunResult, escalationModes?: readonly SandboxMode[]): string;
+export declare function renderResult(result: ShellRunResult & {
+    stopped?: string;
+}, escalationModes?: readonly SandboxMode[]): string;
 /**
- * Shape one background-process read into the `job_output` delta the model
- * sees: the incremental delta, plus the lossy-read notice (with full-stream
- * spill paths) when in-memory truncation dropped unread bytes. Empty-delta
- * rendering (`(no new output)`) is the generic job controller's job.
- * @param read - one incremental read from the process handle.
+ * Shape a foreground call that stopped waiting into the text the model sees:
+ * the output captured so far (one consuming registry read taken at that
+ * point, so `job_output` continues exactly after it), then the still-running
+ * marker and the job hand-off guidance.
+ * @param promoted - the promoted result value: the job id, the wait that
+ *   expired, and the output so far.
+ * @returns the model-facing text for a promoted call.
+ */
+export declare function renderPromoted(promoted: {
+    jobId: string;
+    timeoutMs: number;
+    output: string;
+}): string;
+/**
+ * Shape the one consuming registry read a foreground call embeds in its
+ * result when it stops waiting: the output produced so far, plus the
+ * dropped-output notice (naming the job's spill files) when the model cursor
+ * fell behind the ring, and the sandbox notices. Later `job_output` reads
+ * render the same ring through the job tools.
+ * @param delta - the read's chunks as rendered text.
+ * @param lossy - whether bytes before the delta were evicted unread.
+ * @param spillPaths - the complete-stream files the job currently advertises.
  * @param sandbox - settled sandbox facts, when this was a confined process.
  * @param escalationModes - escalation targets advertised by this composition.
  * @returns the delta text with any loss or sandbox notice appended.
  */
-export declare function renderProcessRead(read: ShellProcessRead, sandbox?: ShellSandboxInfo, escalationModes?: readonly SandboxMode[]): string;
+export declare function renderJobRead(delta: string, lossy: boolean, spillPaths: readonly string[], sandbox?: ShellSandboxInfo, escalationModes?: readonly SandboxMode[]): string;
 /**
  * The exit-status parse is the shared marker-contract half of the shell-tool
  * rendering story, owned by `@deepseek-ai/dsh-shell` so `dsh-tool-pwsh` reuses

package/vendor/command-goal/index.js

@@ -1,4 +1,5 @@
 // dscode-goal-cap-v1
+import { CommandDefinitionId } from "@deepseek-ai/dsh-commands/brand";
 import { GoalError } from "@deepseek-ai/dsh-goal";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 //#region lib/types/index.js
@@ -195,8 +196,9 @@ function executeGoalCommand(ctx, invocation) {
 /** Register the Codex-shaped `/goal` command for every composed command adapter. */
 function apply(ctx) {
 	ctx.commands.register({
+		definitionId: CommandDefinitionId("@deepseek-ai/dsh-command-goal"),
 		name: "goal",
-		description: "set or view the goal for a long-running task",
+		description: "Set or view the goal for a long-running task",
 		input: {
 			hint: "[<objective>|clear|edit <objective>|pause|resume], [<rounds>]",
 			attachments: true