wood-fired-tasks 2.1.0 → 2.2.0

package/dist/cli/commands/list.js

@@ -4,11 +4,22 @@ import { formatTaskTable, colorError, colorWarn, colorInfo } from '../output/for
 import { handleError } from '../output/error-handler.js';
 import { jsonOutput } from '../output/json-output.js';
 const VALID_STATUSES = ['open', 'in_progress', 'done', 'closed', 'blocked'];
+// `all` is a CLI-only sentinel meaning "no server-side status filter" — it is
+// NOT a real task status, so it is accepted by the CLI but never forwarded as
+// `?status=` to the API. Listing every status (including blocked + closed) is
+// exactly what omitting the filter already does server-side.
+const STATUS_ALL = 'all';
 const MAX_LIMIT = 500;
 export const listCommand = new Command('list')
     .description('List tasks with optional filters')
     .option('-p, --project <id>', 'Filter by project ID', parseInt)
-    .option('-s, --status <status>', 'Filter by status')
+    .option('-s, --status <status>', 
+// Default (no --status): the server applies NO status filter, so every
+// status is returned — open, in_progress, blocked, done, AND closed. None
+// are hidden. Pass a single status to narrow, or the explicit sentinel
+// `all` to make "every status (incl. blocked + closed)" self-documenting
+// in scripts. Valid values: open | in_progress | blocked | done | closed | all.
+`Filter by status (default: all statuses shown, incl. blocked + closed). Use 'all' to be explicit.`)
     .option('-a, --assignee <name>', 'Filter by assignee')
     .option('--search <query>', 'Search tasks by title/description')
     .option('--tags <tags>', 'Filter by tags (comma-separated)')
@@ -18,9 +29,12 @@ export const listCommand = new Command('list')
     .option('--offset <n>', 'Zero-based offset for pagination (default 0)', (v) => parseInt(v, 10))
     .action(async (options) => {
     try {
-        // Validate status if provided
-        if (options.status && !VALID_STATUSES.includes(options.status)) {
-            console.error(colorError(`Invalid status: ${options.status}. Valid options: ${VALID_STATUSES.join(', ')}`));
+        // Validate status if provided. `all` is the explicit "every status"
+        // sentinel and is accepted alongside the real statuses.
+        if (options.status &&
+            options.status !== STATUS_ALL &&
+            !VALID_STATUSES.includes(options.status)) {
+            console.error(colorError(`Invalid status: ${options.status}. Valid options: ${[...VALID_STATUSES, STATUS_ALL].join(', ')}`));
             process.exitCode = 1;
             return;
         }
@@ -50,7 +64,9 @@ export const listCommand = new Command('list')
         if (options.project !== undefined) {
             filters.project_id = options.project;
         }
-        if (options.status) {
+        // `all` means "no server-side status filter" — every status (incl.
+        // blocked + closed) is returned. Any other value narrows to that status.
+        if (options.status && options.status !== STATUS_ALL) {
             filters.status = options.status;
         }
         if (options.assignee) {
@@ -81,10 +97,17 @@ export const listCommand = new Command('list')
         const program = listCommand.parent;
         const globalOpts = program?.optsWithGlobals() || {};
         const isJsonMode = globalOpts['json'] || false;
+        // Effective status filter, echoed so machine consumers can detect
+        // exactly what they asked for. `all` is reported when no status was
+        // requested (or `--status all` was passed) — i.e. blocked + closed are
+        // included rather than silently filtered out.
+        const statusFilter = options.status && options.status !== STATUS_ALL ? options.status : STATUS_ALL;
         // Display results
         if (isJsonMode) {
-            // JSON mode: output envelope to stdout
-            jsonOutput(tasks, { count: tasks.length });
+            // JSON mode: output envelope to stdout. `statusFilter` names the
+            // effective filter so scripts never mistake a status transition
+            // (e.g. open → blocked) for a deleted task.
+            jsonOutput(tasks, { count: tasks.length, statusFilter });
         }
         else {
             // Terminal mode: formatted output

package/dist/cli/commands/login.d.ts

@@ -11,6 +11,9 @@ import type { PromptIO } from '../util/prompt.js';
  * - `hostname`    — local hostname, surfaced to the server for PAT auto-naming.
  * - `tokenName`   — optional advisory PAT name (`--token-name`).
  * - `openBrowser` — when `true`, best-effort auto-open the verification URL.
+ * - `opener`      — injectable browser-launch seam. Defaults to the real
+ *                   {@link openBrowser}. Tests pass a stub so the suite never
+ *                   spawns a real browser; production never overrides it.
  * - `isJson`      — when `true`, emit newline-separated JSON envelopes on stdout
  *                   instead of human-friendly text on stderr.
  */
@@ -20,6 +23,13 @@ export interface RunDeviceLoginArgs {
     hostname: string;
     tokenName?: string;
     openBrowser: boolean;
+    /**
+     * Injectable browser opener (defaults to {@link openBrowser}). This is the
+     * seam that replaces the former no-browser env bandaid: tests inject a
+     * stub instead of relying on a global env flag that, if leaked, would
+     * silently disable browser login for real users.
+     */
+    opener?: (url: string) => boolean;
     isJson: boolean;
 }
 /** Outcome of {@link runDeviceLogin}. `ok: false` means the flow already emitted

package/dist/cli/commands/login.js

@@ -48,6 +48,7 @@ function emitJsonEvent(event) {
  */
 export async function runDeviceLogin(args) {
     const { baseUrl, clientId, hostname, tokenName, openBrowser: shouldOpenBrowser, isJson } = args;
+    const opener = args.opener ?? openBrowser;
     // 2. Request a device_code from the server.
     let codeResponse;
     try {
@@ -99,7 +100,7 @@ export async function runDeviceLogin(args) {
     }
     // 4. Best-effort browser launch (skipped if !openBrowser).
     if (shouldOpenBrowser) {
-        const opened = openBrowser(verification_uri_complete);
+        const opened = opener(verification_uri_complete);
         if (!isJson) {
             if (opened) {
                 process.stderr.write('(Opening browser...)\n');

package/dist/cli/commands/models.d.ts

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { type ModelPolicy } from '../../schemas/model-policy.schema.js';
+import { type ModelPolicy, type PipelineRole } from '../../schemas/model-policy.schema.js';
 /**
  * Configurable Task Models (Task 12) — CLI surface.
  *
@@ -14,9 +14,13 @@ import { type ModelPolicy } from '../../schemas/model-policy.schema.js';
  * `settings-set-models.ts`). They turn the flat Commander option bag into a
  * validated partial `ModelPolicy` (`ModelPolicySchema.parse`).
  */
-/** The three dispatch roles a policy can configure. */
+/**
+ * The three dispatch roles a policy can configure. Derived from the
+ * single-source `PIPELINE_ROLES` (task #929); kept under the CLI-local names
+ * so existing call sites are undisturbed.
+ */
 export declare const MODEL_ROLES: readonly ["execution", "validation", "planning"];
-export type ModelRole = (typeof MODEL_ROLES)[number];
+export type ModelRole = PipelineRole;
 /**
  * Register the per-role model flags on a Commander command:
  *   --<role>-<category> <model|auto>   (byCategory route)
@@ -41,4 +45,35 @@ export declare function buildModelPolicyFromOptions(options: Record<string, stri
  * `set-models` UX. Returns a schema-validated complete policy to persist.
  */
 export declare function mergeModelPolicies(existing: ModelPolicy | null | undefined, partial: ModelPolicy): ModelPolicy;
+/**
+ * Read `--json` off the GLOBAL program options for a set-models subcommand.
+ * The flag is registered on the root program, so subcommands must reach up via
+ * `optsWithGlobals()`. Shared by `project-set-models` / `settings-set-models`.
+ */
+export declare function resolveSetModelsJsonMode(command: Command): boolean;
+/**
+ * Outcome of {@link parseSetModelsOptions}: either a validated partial policy
+ * ready to merge+persist, or a `stop` sentinel meaning the command already
+ * emitted its message and set `process.exitCode = 1` — the caller just returns.
+ */
+export type ParseSetModelsResult = {
+    stop: true;
+} | {
+    stop: false;
+    policy: ModelPolicy;
+};
+/**
+ * Shared set-models preamble for `project-set-models` / `settings-set-models`:
+ *
+ *   1. Assemble + validate a partial policy from the flat option bag
+ *      (`buildModelPolicyFromOptions`). On a validation error, print it and
+ *      set `process.exitCode = 1`, returning `{ stop: true }`.
+ *   2. When no model flags were supplied, warn and set `process.exitCode = 1`,
+ *      returning `{ stop: true }`.
+ *   3. Otherwise return `{ stop: false, policy }`.
+ *
+ * Extracting this keeps the two commands' parse/validate/no-flags behavior and
+ * output byte-identical from one source.
+ */
+export declare function parseSetModelsOptions(options: Record<string, string | undefined>): ParseSetModelsResult;
 export declare const modelsCommand: Command;

package/dist/cli/commands/models.js

@@ -1,9 +1,9 @@
 import { Command } from 'commander';
 import { listModels } from '../api/client.js';
-import { colorWarn } from '../output/formatters.js';
+import { colorError, colorWarn } from '../output/formatters.js';
 import { handleError } from '../output/error-handler.js';
 import { jsonOutput } from '../output/json-output.js';
-import { POWER_CATEGORIES, ModelPolicySchema, } from '../../schemas/model-policy.schema.js';
+import { PIPELINE_ROLES, POWER_CATEGORIES, ModelPolicySchema, } from '../../schemas/model-policy.schema.js';
 /**
  * Configurable Task Models (Task 12) — CLI surface.
  *
@@ -18,8 +18,12 @@ import { POWER_CATEGORIES, ModelPolicySchema, } from '../../schemas/model-policy
  * `settings-set-models.ts`). They turn the flat Commander option bag into a
  * validated partial `ModelPolicy` (`ModelPolicySchema.parse`).
  */
-/** The three dispatch roles a policy can configure. */
-export const MODEL_ROLES = ['execution', 'validation', 'planning'];
+/**
+ * The three dispatch roles a policy can configure. Derived from the
+ * single-source `PIPELINE_ROLES` (task #929); kept under the CLI-local names
+ * so existing call sites are undisturbed.
+ */
+export const MODEL_ROLES = PIPELINE_ROLES;
 /**
  * Register the per-role model flags on a Commander command:
  *   --<role>-<category> <model|auto>   (byCategory route)
@@ -106,6 +110,46 @@ export function mergeModelPolicies(existing, partial) {
     }
     return ModelPolicySchema.parse(merged);
 }
+/**
+ * Read `--json` off the GLOBAL program options for a set-models subcommand.
+ * The flag is registered on the root program, so subcommands must reach up via
+ * `optsWithGlobals()`. Shared by `project-set-models` / `settings-set-models`.
+ */
+export function resolveSetModelsJsonMode(command) {
+    const globalOpts = command.parent?.optsWithGlobals() || {};
+    return Boolean(globalOpts['json']);
+}
+/**
+ * Shared set-models preamble for `project-set-models` / `settings-set-models`:
+ *
+ *   1. Assemble + validate a partial policy from the flat option bag
+ *      (`buildModelPolicyFromOptions`). On a validation error, print it and
+ *      set `process.exitCode = 1`, returning `{ stop: true }`.
+ *   2. When no model flags were supplied, warn and set `process.exitCode = 1`,
+ *      returning `{ stop: true }`.
+ *   3. Otherwise return `{ stop: false, policy }`.
+ *
+ * Extracting this keeps the two commands' parse/validate/no-flags behavior and
+ * output byte-identical from one source.
+ */
+export function parseSetModelsOptions(options) {
+    let policy;
+    try {
+        policy = buildModelPolicyFromOptions(options);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(colorError(`Invalid model policy: ${msg}`));
+        process.exitCode = 1;
+        return { stop: true };
+    }
+    if (policy === undefined) {
+        console.log(colorWarn('No model flags specified. Use --help to see available options.'));
+        process.exitCode = 1;
+        return { stop: true };
+    }
+    return { stop: false, policy };
+}
 // ── `models list` ───────────────────────────────────────────
 const modelsListCommand = new Command('list')
     .description('List the available Claude model catalog (runtime-discovered)')

package/dist/cli/commands/project-set-models.js

@@ -1,9 +1,9 @@
 import { Command } from 'commander';
 import { getProject, updateProject } from '../api/client.js';
-import { formatProjectDetail, colorError, colorWarn, colorSuccess } from '../output/formatters.js';
+import { formatProjectDetail, colorError, colorSuccess } from '../output/formatters.js';
 import { handleError } from '../output/error-handler.js';
 import { jsonOutput } from '../output/json-output.js';
-import { addModelPolicyOptions, buildModelPolicyFromOptions, mergeModelPolicies, } from './models.js';
+import { addModelPolicyOptions, mergeModelPolicies, parseSetModelsOptions, resolveSetModelsJsonMode, } from './models.js';
 /**
  * Configurable Task Models (Task 12) — `tasks project-set-models <id> [flags]`.
  *
@@ -24,21 +24,10 @@ export const projectSetModelsCommand = addModelPolicyOptions(new Command('projec
             process.exitCode = 1;
             return;
         }
-        let modelPolicy;
-        try {
-            modelPolicy = buildModelPolicyFromOptions(options);
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            console.error(colorError(`Invalid model policy: ${msg}`));
-            process.exitCode = 1;
-            return;
-        }
-        if (modelPolicy === undefined) {
-            console.log(colorWarn('No model flags specified. Use --help to see available options.'));
-            process.exitCode = 1;
+        const parsed = parseSetModelsOptions(options);
+        if (parsed.stop)
             return;
-        }
+        const modelPolicy = parsed.policy;
         // Fetch-merge-write: the server replaces the column wholesale, so merge
         // the partial flag policy over the stored one here to keep incremental
         // invocations non-destructive.
@@ -47,9 +36,7 @@ export const projectSetModelsCommand = addModelPolicyOptions(new Command('projec
             model_policy: mergeModelPolicies(current.model_policy ?? null, modelPolicy),
         };
         const project = await updateProject(id, updates);
-        const program = projectSetModelsCommand.parent;
-        const globalOpts = program?.optsWithGlobals() || {};
-        const isJsonMode = globalOpts['json'] || false;
+        const isJsonMode = resolveSetModelsJsonMode(projectSetModelsCommand);
         if (isJsonMode) {
             jsonOutput({ project }, { id: project.id });
         }

package/dist/cli/commands/self-update.d.ts

@@ -1,12 +1,20 @@
 import { Command } from 'commander';
 import { type ChildProcess, type SpawnOptions } from 'child_process';
+import { type CopySkillsResult, type CopyAgentsResult } from './setup.js';
 /**
  * `tasks self-update` — frictionless self-update for npm-global installs
  * (project #36, task #739).
  *
- * Spawns `npm i -g wood-fired-tasks@latest` and exits with that child's exit
- * code. The DB schema does NOT need touching here — migrate-on-next-serve
- * handles it the next time the service boots against the upgraded binary.
+ * Spawns `npm i -g wood-fired-tasks@latest`, then re-syncs the bundled
+ * skills/agents into ~/.claude (task #934): the npm install replaces the
+ * files under the global prefix in place, so the post-install copySkills /
+ * copyAgents read the NEW version's assets even though this process is still
+ * running the old binary. Without this step, any release that adds or
+ * changes a skill leaves self-updaters with stale ~/.claude/commands/tasks
+ * while self-update reports success — violating the README's "keep it up to
+ * date" contract. The DB schema does NOT need touching here —
+ * migrate-on-next-serve handles it the next time the service boots against
+ * the upgraded binary.
  *
  * EACCES policy: a global npm install under a root-owned prefix fails with
  * EACCES. We DO NOT escalate (no sudo / runas / elevation of ANY kind).
@@ -17,9 +25,14 @@ import { type ChildProcess, type SpawnOptions } from 'child_process';
  */
 export type SpawnFn = (command: string, args: readonly string[], options: SpawnOptions) => ChildProcess;
 export type NotifyFn = (currentVersion: string) => void | Promise<void>;
+export type SyncAssetsFn = () => {
+    skills: CopySkillsResult;
+    agents: CopyAgentsResult;
+};
 export interface SelfUpdateDeps {
     spawn?: SpawnFn;
     notify?: NotifyFn;
+    syncAssets?: SyncAssetsFn;
 }
 /**
  * True when a spawn error / non-zero exit looks like an EACCES-class

package/dist/cli/commands/self-update.js

@@ -3,6 +3,7 @@ import { spawn as nodeSpawn } from 'child_process';
 import { colorError, colorInfo, colorSuccess, colorWarn } from '../output/formatters.js';
 import { VERSION } from '../../utils/version.js';
 import { buildNpmInvocation } from '../util/npm-spawn.js';
+import { copySkills, copyAgents } from './setup.js';
 const PACKAGE_NAME = 'wood-fired-tasks';
 /**
  * True when a spawn error / non-zero exit looks like an EACCES-class
@@ -98,6 +99,7 @@ export const selfUpdateCommand = new Command('self-update')
     const deps = selfUpdateCommand._deps ?? {};
     const spawn = deps.spawn ?? nodeSpawn;
     const notify = deps.notify ?? defaultNotify;
+    const syncAssets = deps.syncAssets ?? (() => ({ skills: copySkills(), agents: copyAgents() }));
     // update-notifier nudge: surface a "newer version available" hint before
     // we attempt the upgrade. Best-effort and never blocks the update.
     await notify(VERSION);
@@ -119,6 +121,25 @@ export const selfUpdateCommand = new Command('self-update')
         process.exitCode = code ?? 1;
         return;
     }
+    // npm replaced the package files under the global prefix in place, so the
+    // sync below reads the NEW version's dist/skills even though this process
+    // still runs the old binary. A sync failure is loud and non-zero: "update
+    // succeeded but your skills are stale" is exactly the silent state this
+    // step exists to eliminate (task #934).
+    try {
+        const { skills, agents } = syncAssets();
+        const refreshed = skills.written.length + agents.written.length;
+        console.log(refreshed > 0
+            ? colorInfo(`Refreshed ${skills.written.length} skill(s) in ${skills.destDir} and ${agents.written.length} agent(s) in ${agents.destDir}`)
+            : colorInfo(`Skills and agents already up to date in ${skills.destDir}`));
+    }
+    catch (syncError) {
+        const message = syncError instanceof Error ? syncError.message : String(syncError);
+        console.error(colorError(`Update installed, but syncing bundled skills/agents into ~/.claude failed: ${message}`));
+        console.error(colorWarn(`Run \`${PACKAGE_NAME} setup\` to retry the skills sync.`));
+        process.exitCode = 1;
+        return;
+    }
     console.log(colorSuccess(`Updated ${PACKAGE_NAME}. The schema migrates automatically on next serve.`));
     process.exitCode = 0;
 });

package/dist/cli/commands/settings-set-models.js

@@ -1,9 +1,9 @@
 import { Command } from 'commander';
 import { getModelPolicyDefault, setModelPolicyDefault } from '../api/client.js';
-import { colorError, colorWarn, colorSuccess } from '../output/formatters.js';
+import { colorSuccess } from '../output/formatters.js';
 import { handleError } from '../output/error-handler.js';
 import { jsonOutput } from '../output/json-output.js';
-import { addModelPolicyOptions, buildModelPolicyFromOptions, mergeModelPolicies, } from './models.js';
+import { addModelPolicyOptions, mergeModelPolicies, parseSetModelsOptions, resolveSetModelsJsonMode, } from './models.js';
 /**
  * Configurable Task Models (Task 12) — `tasks settings-set-models [flags]`.
  *
@@ -16,28 +16,15 @@ import { addModelPolicyOptions, buildModelPolicyFromOptions, mergeModelPolicies,
  */
 export const settingsSetModelsCommand = addModelPolicyOptions(new Command('settings-set-models').description('Set the database-wide default model policy (per-role / per-category routing)')).action(async (options) => {
     try {
-        let modelPolicy;
-        try {
-            modelPolicy = buildModelPolicyFromOptions(options);
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            console.error(colorError(`Invalid model policy: ${msg}`));
-            process.exitCode = 1;
-            return;
-        }
-        if (modelPolicy === undefined) {
-            console.log(colorWarn('No model flags specified. Use --help to see available options.'));
-            process.exitCode = 1;
+        const parsed = parseSetModelsOptions(options);
+        if (parsed.stop)
             return;
-        }
+        const modelPolicy = parsed.policy;
         // Fetch-merge-write: keep incremental invocations non-destructive (the
         // server replaces the stored default wholesale).
         const current = await getModelPolicyDefault();
         const persisted = await setModelPolicyDefault(mergeModelPolicies(current, modelPolicy));
-        const program = settingsSetModelsCommand.parent;
-        const globalOpts = program?.optsWithGlobals() || {};
-        const isJsonMode = globalOpts['json'] || false;
+        const isJsonMode = resolveSetModelsJsonMode(settingsSetModelsCommand);
         if (isJsonMode) {
             jsonOutput({ model_policy: persisted });
         }

package/dist/cli/commands/setup.d.ts

@@ -333,6 +333,14 @@ export interface RunSetupInteractiveOptions extends RunSetupOptions {
      * here without standing up a full device-flow server.
      */
     deviceLogin?: typeof runDeviceLogin;
+    /**
+     * Injectable browser opener forwarded to the device-flow login (replaces the
+     * former no-browser env bandaid). Defaults to undefined, so production
+     * uses the real {@link openBrowser}. Tests that drive the REAL device flow
+     * (without stubbing {@link deviceLogin}) pass a stub here so the suite never
+     * spawns a real browser on a DISPLAY-set desktop.
+     */
+    opener?: (url: string) => boolean;
     /**
      * Injectable manual-PAT persistence seam (#809). Defaults to
      * {@link persistManualPat} (validate the PAT against `GET /api/v1/me`, then

package/dist/cli/commands/setup.js

@@ -720,6 +720,7 @@ export async function runRemoteOnboarding(options = {}) {
                 clientId: process.env['OIDC_DEVICE_CLIENT_ID'] ?? 'wft-cli',
                 hostname: os.hostname(),
                 openBrowser: true,
+                ...(options.opener !== undefined && { opener: options.opener }),
                 isJson: false,
             });
             deviceOk = result.ok;

package/dist/cli/commands/update.js

@@ -15,6 +15,8 @@ export const updateCommand = new Command('update')
     .option('-a, --assignee <name>', 'New assignee')
     .option('--due <date>', 'New due date (ISO8601)')
     .option('--tags <tags>', 'New tags (comma-separated, replaces existing)')
+    .option('--blocked-by <ids>', 'Blocking task IDs (comma-separated). Only valid with --status blocked: ' +
+    'adds the blocking dependency edge(s) and sets the status atomically')
     .action(async (idStr, options) => {
     try {
         // Parse and validate task ID
@@ -59,6 +61,24 @@ export const updateCommand = new Command('update')
         if (options.tags !== undefined) {
             updates.tags = options.tags.split(',').map((tag) => tag.trim());
         }
+        if (options.blockedBy !== undefined) {
+            // Task #1004: atomic block-with-dependency. Mirror the server's narrow
+            // semantics client-side so the misuse fails before the wire.
+            if (options.status !== 'blocked') {
+                console.error(colorError('--blocked-by is only valid together with --status blocked ' +
+                    '(the edge-add and the status flip commit atomically). ' +
+                    'To add edges without blocking, use `tasks dep-add` instead.'));
+                process.exitCode = 1;
+                return;
+            }
+            const blockedBy = options.blockedBy.split(',').map((s) => parseInt(s.trim(), 10));
+            if (blockedBy.length === 0 || blockedBy.some((n) => isNaN(n) || n <= 0)) {
+                console.error(colorError('Invalid --blocked-by: must be comma-separated positive task IDs'));
+                process.exitCode = 1;
+                return;
+            }
+            updates.blocked_by = blockedBy;
+        }
         // Check if any updates were specified
         if (Object.keys(updates).length === 0) {
             console.log(colorWarn('No updates specified. Use --help to see available options.'));

package/dist/events/event-bus.d.ts

@@ -1,4 +1,4 @@
-import { TaskEvent, ProjectEvent } from './types.js';
+import { TaskEvent, ProjectEvent, ClaimReleasedEvent } from './types.js';
 /**
  * Options for {@link EventBus.subscribe}.
  *
@@ -90,6 +90,7 @@ type AppEvents = {
     'task.deleted': TaskEvent;
     'task.status_changed': TaskEvent;
     'task.claimed': TaskEvent;
+    'task.claim_released': ClaimReleasedEvent;
     'project.created': ProjectEvent;
     'project.updated': ProjectEvent;
     'project.deleted': ProjectEvent;

package/dist/events/event-bus.js

@@ -178,6 +178,7 @@ export class EventBus {
                 this.emitter.listenerCount('task.deleted') +
                 this.emitter.listenerCount('task.status_changed') +
                 this.emitter.listenerCount('task.claimed') +
+                this.emitter.listenerCount('task.claim_released') +
                 this.emitter.listenerCount('project.created') +
                 this.emitter.listenerCount('project.updated') +
                 this.emitter.listenerCount('project.deleted'),

package/dist/events/sse-manager.d.ts

@@ -34,7 +34,7 @@ export declare class SSEManager {
     private heartbeatInterval?;
     private createdAt;
     private totalEventsSent;
-    constructor(maxBufferSize?: number, bufferTtlMs?: number, // 5 minutes
+    constructor(maxBufferSize?: number, bufferTtlMs?: number, // 10 minutes — keep >= maxConnectionAgeMs
     heartbeatIntervalMs?: number, // 30 seconds
     maxConnectionAgeMs?: number, // 10 minutes
     maxConnectionsPerKey?: number, maxConnectionsPerIp?: number, maxConnections?: number);
@@ -56,13 +56,42 @@ export declare class SSEManager {
         apiKeyFingerprint: string;
         ip: string;
     }): void;
+    /**
+     * Remove a connection from the broadcast map WITHOUT touching the socket.
+     *
+     * task #1001: this is only safe when the peer socket is already gone — it
+     * is the cleanup callback for the raw `close`/`error` events registered in
+     * `addConnection`. Every server-initiated eviction (age-out, send failure,
+     * heartbeat failure, shutdown) MUST go through `closeConnection` instead,
+     * which ends the stream so the client observes a FIN and reconnects.
+     */
     removeConnection(connectionId: string): void;
+    /**
+     * task #1001: server-initiated eviction. Removes the connection from the
+     * broadcast map AND closes the underlying stream so the client sees the
+     * connection end and its reconnect logic fires (EventSource-style clients
+     * reconnect with `Last-Event-Id` and resume via `replayEvents`).
+     *
+     * Before this fix, the age-out path in the heartbeat sweep called
+     * `removeConnection` only — the map entry vanished but the TCP socket
+     * stayed open with no events, no pings and no FIN, so clients went
+     * silently deaf after maxConnectionAgeMs (reproduced 3x in the Tiny
+     * Worlds orchestration pilot, 2026-06-10).
+     */
+    private closeConnection;
     broadcast(event: EventPayload<unknown>): void;
     private matchesFilters;
     private sendEvent;
     private replayEvents;
     private pruneEventBuffer;
     private startHeartbeat;
+    /**
+     * One heartbeat tick: ping every live connection and evict connections
+     * past maxConnectionAgeMs. Extracted from the setInterval callback so
+     * integration tests can drive a sweep deterministically without faking
+     * 30s of wall-clock time against a real listening socket (task #1001).
+     */
+    private heartbeatSweep;
     shutdown(): void;
     /**
      * Check if SSE manager is healthy (has active heartbeat)