@cjhyy/code-shell-core 0.5.0-rc.2 → 0.6.0-rc.2

package/dist/tool-system/builtin/agent-notifications.js

@@ -94,8 +94,7 @@ class AgentNotificationBus {
             // Mirrors NotificationQueue.enqueue — refuse undefined / "" so the
             // server-side subscriber never has to defend against it.
             logger.warn("agent_notification_bus.invalid_session_id", {
-                agentId: event.agentId,
-                status: event.status,
+                eventType: event.type,
                 sessionIdType: typeof sessionId,
             });
             return;
@@ -132,6 +131,10 @@ export function notificationItemToStreamEvent(item) {
     };
     if (item.name !== undefined)
         event.name = item.name;
+    if (item.workKind !== undefined)
+        event.workKind = item.workKind;
+    if (item.command !== undefined)
+        event.command = item.command;
     if (item.finalText !== undefined)
         event.finalText = item.finalText;
     if (item.error !== undefined)
@@ -163,7 +166,10 @@ export function buildNotificationMessage(items) {
     const agents = items
         .map((item) => {
         const nameAttr = item.name ? ` name="${escapeXmlAttr(item.name)}"` : "";
-        const opening = `  <agent id="${escapeXmlAttr(item.agentId)}"${nameAttr} status="${item.status}">`;
+        // For DriveClaudeCode jobs, expose the real claude session id so the model
+        // can cite it / recover the full result from disk if needed.
+        const ccAttr = item.ccSessionId ? ` ccSessionId="${escapeXmlAttr(item.ccSessionId)}"` : "";
+        const opening = `  <agent id="${escapeXmlAttr(item.agentId)}"${nameAttr} status="${item.status}"${ccAttr}>`;
         const desc = `    <description>${escapeXmlText(item.description)}</description>`;
         const body = item.status === "completed"
             ? `    <result>\n${escapeXmlText(item.finalText ?? "")}\n    </result>`

package/dist/tool-system/builtin/agent-output-file.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Background-agent output files. When an async (run_in_background) agent
+ * finishes, we mirror its final text to `~/.code-shell/agents/<agentId>.txt`
+ * so it can be tailed from outside the process or read back in a later session
+ * — the notificationQueue re-injection remains the PRIMARY path that feeds the
+ * result to the parent agent; this file is just an external-readable copy.
+ *
+ * All writes are best-effort: a failure here must never break the agent
+ * completion path, so callers fire-and-forget and we swallow errors (logging
+ * via the provided logger when present).
+ */
+/** Directory holding per-agent output files. */
+export declare function agentOutputDir(): string;
+/** Absolute path of a given agent's output file. */
+export declare function agentOutputPath(agentId: string): string;
+interface WriteOpts {
+    status: "completed" | "failed";
+    /** Final text (completed) or error message (failed). */
+    body: string;
+    description?: string;
+    name?: string;
+    /** Optional logger.warn for swallowed errors. */
+    onError?: (msg: string, meta: Record<string, unknown>) => void;
+}
+/**
+ * Write (overwrite) an agent's output file. Best-effort: resolves even on
+ * failure. The body is prefixed with a small header so a human tailing the
+ * file sees what it is.
+ */
+export declare function writeAgentOutputFile(agentId: string, opts: WriteOpts): Promise<void>;
+/** Delete a single agent's output file (best-effort). */
+export declare function removeAgentOutputFile(agentId: string): Promise<void>;
+/**
+ * Remove every agent output file. Called on app exit / full registry reset so
+ * the directory doesn't accumulate stale files across runs.
+ */
+export declare function clearAgentOutputFiles(): Promise<void>;
+export {};

package/dist/tool-system/builtin/agent-output-file.js

@@ -0,0 +1,72 @@
+/**
+ * Background-agent output files. When an async (run_in_background) agent
+ * finishes, we mirror its final text to `~/.code-shell/agents/<agentId>.txt`
+ * so it can be tailed from outside the process or read back in a later session
+ * — the notificationQueue re-injection remains the PRIMARY path that feeds the
+ * result to the parent agent; this file is just an external-readable copy.
+ *
+ * All writes are best-effort: a failure here must never break the agent
+ * completion path, so callers fire-and-forget and we swallow errors (logging
+ * via the provided logger when present).
+ */
+import { join } from "node:path";
+import { mkdir, writeFile, rm, readdir } from "node:fs/promises";
+import { userHome } from "../../settings/manager.js";
+/** Directory holding per-agent output files. */
+export function agentOutputDir() {
+    return join(userHome(), ".code-shell", "agents");
+}
+/** Absolute path of a given agent's output file. */
+export function agentOutputPath(agentId) {
+    // agentId is internally generated (`agent-<n>` / uuid-ish) — no separators —
+    // but guard anyway so a hostile id can't escape the directory.
+    const safe = agentId.replace(/[^A-Za-z0-9._-]/g, "_");
+    return join(agentOutputDir(), `${safe}.txt`);
+}
+/**
+ * Write (overwrite) an agent's output file. Best-effort: resolves even on
+ * failure. The body is prefixed with a small header so a human tailing the
+ * file sees what it is.
+ */
+export async function writeAgentOutputFile(agentId, opts) {
+    try {
+        await mkdir(agentOutputDir(), { recursive: true });
+        const header = `# agent ${agentId}` +
+            (opts.name ? ` (${opts.name})` : "") +
+            `\n# status: ${opts.status}` +
+            (opts.description ? `\n# task: ${opts.description}` : "") +
+            `\n\n`;
+        await writeFile(agentOutputPath(agentId), header + (opts.body ?? ""), "utf8");
+    }
+    catch (e) {
+        opts.onError?.("agent_output_file_write_failed", {
+            agentId,
+            error: String(e instanceof Error ? e.message : e),
+        });
+    }
+}
+/** Delete a single agent's output file (best-effort). */
+export async function removeAgentOutputFile(agentId) {
+    try {
+        await rm(agentOutputPath(agentId), { force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Remove every agent output file. Called on app exit / full registry reset so
+ * the directory doesn't accumulate stale files across runs.
+ */
+export async function clearAgentOutputFiles() {
+    try {
+        const dir = agentOutputDir();
+        const names = await readdir(dir);
+        await Promise.all(names
+            .filter((n) => n.endsWith(".txt"))
+            .map((n) => rm(join(dir, n), { force: true })));
+    }
+    catch {
+        // dir may not exist yet — fine
+    }
+}

package/dist/tool-system/builtin/agent-registry.d.ts

@@ -38,6 +38,12 @@ export interface AsyncAgentEntry {
      *  not every concurrent session's. Undefined only for legacy/ad-hoc callers
      *  outside Engine.run. */
     sessionId?: string;
+    /** The sub-agent's OWN child session id (distinct from the parent
+     *  `sessionId` above). AgentSendInput resumes this to continue the agent
+     *  with full transcript replay. With the agent_id===childSid convention
+     *  this equals `agentId`, but it is stored explicitly so the contract is
+     *  not coupled to that identity. Undefined for legacy entries. */
+    childSessionId?: string;
     status: AsyncAgentStatus;
     startedAt: number;
     finishedAt?: number;
@@ -71,6 +77,12 @@ declare class AsyncAgentRegistry {
     touchTranscript(agentId: string): void;
     get(agentId: string): AsyncAgentEntry | undefined;
     list(): AsyncAgentEntry[];
+    /**
+     * Agents spawned by a given session. Drives AgentStatus's default view so a
+     * background-agent listing doesn't surface every concurrent session's agents.
+     * Legacy entries with no sessionId are excluded from a session-scoped query.
+     */
+    listForSession(sessionId: string): AsyncAgentEntry[];
     private markFinished;
     markCompleted(agentId: string): void;
     markFailed(agentId: string): void;

package/dist/tool-system/builtin/agent-registry.js

@@ -81,6 +81,14 @@ class AsyncAgentRegistry {
     list() {
         return [...this.agents.values()];
     }
+    /**
+     * Agents spawned by a given session. Drives AgentStatus's default view so a
+     * background-agent listing doesn't surface every concurrent session's agents.
+     * Legacy entries with no sessionId are excluded from a session-scoped query.
+     */
+    listForSession(sessionId) {
+        return [...this.agents.values()].filter((e) => e.sessionId === sessionId);
+    }
     markFinished(agentId, status) {
         const e = this.agents.get(agentId);
         if (!e)

package/dist/tool-system/builtin/agent.d.ts

@@ -9,12 +9,14 @@
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
 import type { AgentDefinitionRegistry } from "../../agent/agent-definition-registry.js";
+import type { AgentDefinition } from "../../agent/agent-definition.js";
 import type { HookRegistry } from "../../hooks/registry.js";
 export interface AgentTypeOverrides {
     resolvedType?: string;
     model?: string;
     maxTurns?: number;
     toolAllowlist?: string[];
+    skillAllowlist?: string[];
     appendSystemPrompt?: string;
 }
 /**
@@ -32,6 +34,22 @@ export interface AgentTypeOverrides {
  *   than silently running a generic agent.
  */
 export declare function resolveAgentTypeOverrides(agentType: string | undefined, registry: AgentDefinitionRegistry | undefined): AgentTypeOverrides;
+/**
+ * A plugin-bundled agent's frontmatter lists its own skills by BARE name
+ * (`skills: director-skill`), matching Claude Code's convention where a
+ * plugin agent references same-plugin skills unqualified. But the skill
+ * scanner registers plugin skills under their NAMESPACED name
+ * (`mimi-video:director-skill`), and the allowlist filter is an exact match —
+ * so a bare entry never matches and the sub-agent reports the skill "not
+ * found", forcing it to fall back to reading SKILL.md by hand.
+ *
+ * Bridge the two conventions: for a plugin-source agent, rewrite each bare
+ * skill name to `<pluginName>:<skill>`. Names that already carry a namespace
+ * (contain ":") are left untouched, so an agent may still reference another
+ * plugin's skill explicitly. undefined (inherit full pool) and [] (no skills)
+ * pass through unchanged. Non-plugin agents are never rewritten.
+ */
+export declare function namespacePluginSkills(skills: string[] | undefined, source: AgentDefinition["source"], pluginName: string | undefined): string[] | undefined;
 /**
  * Render the "Available agent types" block injected into the Agent tool's
  * description, listing the roles defined in .code-shell/agents/*.md so the
@@ -65,7 +83,9 @@ export declare function emitSubAgentHook(hooks: HookRegistry | undefined, kind:
 export declare const agentToolDef: ToolDefinition;
 export declare function agentTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const agentStatusToolDef: ToolDefinition;
-export declare function agentStatusTool(args: Record<string, unknown>): Promise<string>;
+export declare function agentStatusTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const agentCancelToolDef: ToolDefinition;
 export declare function agentCancelTool(args: Record<string, unknown>): Promise<string>;
+export declare const agentSendInputToolDef: ToolDefinition;
+export declare function agentSendInputTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export {};