@swifty.js/swifty 0.0.31 → 0.0.33

package/dist/lib/{chunk-J6AV7SIF.js → chunk-AFYPVA5C.js}

@@ -1,16 +1,16 @@
 import {
   normalizeToolResultContentBlock
 } from "./chunk-XT67KGWE.js";
+import {
+  McpCallTool
+} from "./chunk-BCBD34D2.js";
 import {
   ContextTooLongError,
   DEFAULT_CONTEXT_WINDOW,
   DEFAULT_MAX_OUTPUT_TOKENS,
   REJECTED_TOOL_RESULT,
   RateLimitError
-} from "./chunk-OQIQOU5S.js";
-import {
-  McpCallTool
-} from "./chunk-FZ4Y6MBN.js";
+} from "./chunk-3OFLDUAW.js";
 import {
   asErrorString,
   asRecord,
@@ -18,7 +18,211 @@ import {
   createChildLogger,
   isObject,
   strArg
-} from "./chunk-EY7HE52Q.js";
+} from "./chunk-3XCGUKGJ.js";
+
+// src/telemetry/instrumentation.ts
+import { createHash } from "crypto";
+
+// src/telemetry/index.ts
+var noopObservation = {
+  end: () => void 0,
+  recordException: () => void 0,
+  startChild: () => noopObservation,
+  update: () => void 0
+};
+var noopRuntime = {
+  captureError: () => void 0,
+  emitLog: () => void 0,
+  flush: () => Promise.resolve(),
+  recordMetric: () => void 0,
+  setMode: () => void 0,
+  shutdown: () => Promise.resolve(),
+  startObservation: () => noopObservation
+};
+var runtime = noopRuntime;
+var initialization = null;
+var shutdown = null;
+function getTelemetryRuntime() {
+  return runtime;
+}
+function captureTelemetryError(error, context) {
+  runtime.captureError(error, context);
+}
+async function shutdownTelemetry() {
+  if (shutdown) {
+    return shutdown;
+  }
+  shutdown = (async () => {
+    await initialization;
+    await runtime.shutdown();
+    runtime = noopRuntime;
+  })();
+  return shutdown;
+}
+
+// src/telemetry/instrumentation.ts
+var llmMetadata = /* @__PURE__ */ new WeakMap();
+function elapsedMilliseconds(startedAt) {
+  return performance.now() - startedAt;
+}
+function sessionHash(sessionId) {
+  if (!sessionId) {
+    return void 0;
+  }
+  return createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+}
+function metadataFor(client) {
+  return llmMetadata.get(client) ?? {
+    model: "unknown",
+    protocol: client.protocol ?? "unknown"
+  };
+}
+function recordUsage(usage, attributes) {
+  const runtime2 = getTelemetryRuntime();
+  const values = {
+    cache_creation: usage.cacheCreationInputTokens,
+    cache_read: usage.cacheReadInputTokens,
+    input: usage.inputTokens,
+    output: usage.outputTokens
+  };
+  for (const [tokenType, value] of Object.entries(values)) {
+    if (value > 0) {
+      runtime2.recordMetric("swifty.llm.tokens", "counter", value, {
+        ...attributes,
+        "token.type": tokenType
+      });
+    }
+  }
+}
+function registerLlmClient(client, metadata) {
+  llmMetadata.set(client, metadata);
+  return client;
+}
+function startAgentTelemetry(sessionId, client) {
+  const runtime2 = getTelemetryRuntime();
+  const metadata = metadataFor(client);
+  const hashedSessionId = sessionHash(sessionId);
+  const attributes = {
+    protocol: metadata.protocol,
+    ...hashedSessionId ? { "session.hash": hashedSessionId } : {}
+  };
+  runtime2.recordMetric("swifty.agent.runs", "counter", 1, {
+    protocol: metadata.protocol
+  });
+  return {
+    observation: runtime2.startObservation("agent", "swifty.agent.run", attributes),
+    protocol: metadata.protocol,
+    startedAt: performance.now()
+  };
+}
+function endAgentTelemetry(telemetry, outcome) {
+  const runtime2 = getTelemetryRuntime();
+  telemetry.observation.update({ metadata: { outcome } });
+  telemetry.observation.end();
+  runtime2.recordMetric(
+    "swifty.agent.duration",
+    "histogram",
+    elapsedMilliseconds(telemetry.startedAt),
+    { outcome, protocol: telemetry.protocol }
+  );
+}
+async function* observeLlmStream(client, stream, parent) {
+  const runtime2 = getTelemetryRuntime();
+  const metadata = metadataFor(client);
+  const attributes = {
+    model: metadata.model,
+    protocol: metadata.protocol
+  };
+  const observation = parent.observation.startChild(
+    "generation",
+    "swifty.llm.generate",
+    attributes
+  );
+  const startedAt = performance.now();
+  let completionStartTime;
+  let outcome = "incomplete";
+  runtime2.recordMetric("swifty.llm.requests", "counter", 1, attributes);
+  try {
+    for await (const event of stream) {
+      if (!completionStartTime && event.type !== "stream_end") {
+        completionStartTime = /* @__PURE__ */ new Date();
+        runtime2.recordMetric(
+          "swifty.llm.time_to_first_token",
+          "histogram",
+          elapsedMilliseconds(startedAt),
+          attributes
+        );
+      }
+      if (event.type === "stream_end") {
+        outcome = "completed";
+        const usageDetails = {
+          cacheCreationInput: event.usage.cacheCreationInputTokens,
+          cacheReadInput: event.usage.cacheReadInputTokens,
+          input: event.usage.inputTokens,
+          output: event.usage.outputTokens
+        };
+        observation.update({
+          completionStartTime,
+          metadata: {
+            outcome,
+            protocol: metadata.protocol,
+            stopReason: event.stopReason
+          },
+          model: metadata.model,
+          usageDetails
+        });
+        recordUsage(event.usage, attributes);
+      }
+      yield event;
+    }
+  } catch (error) {
+    outcome = "error";
+    observation.recordException(error);
+    observation.update({ metadata: { outcome, protocol: metadata.protocol } });
+    runtime2.emitLog("swifty.llm.error", "error", {
+      "error.type": error instanceof Error ? error.name : typeof error,
+      ...attributes
+    });
+    throw error;
+  } finally {
+    observation.end();
+    runtime2.recordMetric("swifty.llm.duration", "histogram", elapsedMilliseconds(startedAt), {
+      ...attributes,
+      outcome
+    });
+  }
+}
+async function observeToolExecution(toolName, operation, parent) {
+  const runtime2 = getTelemetryRuntime();
+  const attributes = { tool: toolName };
+  const observation = parent.observation.startChild("tool", "swifty.tool.execute", attributes);
+  const startedAt = performance.now();
+  let outcome = "error";
+  runtime2.recordMetric("swifty.tool.calls", "counter", 1, attributes);
+  try {
+    const result = await operation();
+    outcome = result.isError ? "error" : "completed";
+    observation.update({
+      level: result.isError ? "ERROR" : "DEFAULT",
+      metadata: { outcome, tool: toolName },
+      ...result.isError ? { statusMessage: "Tool returned an error" } : {}
+    });
+    return result;
+  } catch (error) {
+    observation.recordException(error);
+    runtime2.emitLog("swifty.tool.error", "error", {
+      "error.type": error instanceof Error ? error.name : typeof error,
+      tool: toolName
+    });
+    throw error;
+  } finally {
+    observation.end();
+    runtime2.recordMetric("swifty.tool.duration", "histogram", elapsedMilliseconds(startedAt), {
+      outcome,
+      tool: toolName
+    });
+  }
+}
 
 // src/agent/streaming-executor.ts
 var log = createChildLogger({ module: "agent" });
@@ -26,9 +230,11 @@ var StreamingExecutor = class {
   pending = [];
   registry;
   ctx;
-  constructor(registry, ctx) {
+  telemetry;
+  constructor(registry, ctx, telemetry) {
     this.registry = registry;
     this.ctx = ctx;
+    this.telemetry = telemetry;
   }
   submit(toolId, toolName, args) {
     this.pending.push({ toolId, toolName, arguments: args });
@@ -59,7 +265,11 @@ var StreamingExecutor = class {
         };
       }
       try {
-        const result = await tool.execute(this.ctx, call.arguments);
+        const result = await observeToolExecution(
+          call.toolName,
+          () => tool.execute({ ...this.ctx, toolCallId: call.toolId }, call.arguments),
+          this.telemetry
+        );
         return {
           toolId: call.toolId,
           toolName: call.toolName,
@@ -443,7 +653,7 @@ function recordsToCamelUses(recs) {
   return recs?.map((tu) => ({
     toolUseId: tu.tool_use_id,
     toolName: tu.tool_name,
-    arguments: tu.arguments,
+    arguments: tu.arguments ?? {},
     providerItemId: tu.provider_item_id
   }));
 }
@@ -1264,7 +1474,7 @@ Direct bounded research, implementation, and verification; synthesize evidence a
 
 ## Delegation
 - Give each worker a purpose, self-contained context, paths, scope, edit permissions, expected output, and checks. Synthesize findings before assigning follow-up work.
-- One-shot Agent calls return results inline, even with run_in_background; that flag only restricts tools, not execution timing.
+- One-shot Agent calls return inline by default. With run_in_background=true they return a task ID immediately and report completion through a task notification.
 - Persistent async workers use TeamCreate plus Agent's team_name. In this restricted mode TeamCreate is unavailable; Agent with team_name can create the team on demand. Without team_name, expect a one-shot result.
 - Parallelize independent tasks. Assign one writer per shared file set and sequence dependent changes. Worktrees isolate changes but require explicit integration.
 - Delegate Git operations only within user authorization. Never require unsolicited commits or pushes; preserve unrelated work and respect permission/hook denials.
@@ -1276,7 +1486,7 @@ After launching persistent work, give a brief user update and wait for notificat
 
 ## Verification
 Require observed evidence: changed paths, checks run, results, and blockers. Implementation workers should run relevant tests; use independent review when warranted, not as a mandatory extra phase. Exercise actual behavior, investigate failures, and distinguish verified outcomes from worker claims. Report what remains unverified.`;
-var coordinatorSparseReminder = `Coordinator mode: you cannot read files, run commands, or edit code. Tools: Agent, SendMessage, TaskStop, SyntheticOutput, TeamDelete. One-shot Agent returns inline, even with run_in_background; persistent team workers report via team-notification (from= name). Do not poll workers through agents, predict results, overlap shared-file writes, or request unsolicited commits/pushes. Synthesize and verify evidence before reporting.`;
+var coordinatorSparseReminder = `Coordinator mode: you cannot read files, run commands, or edit code. Tools: Agent, SendMessage, TaskStop, SyntheticOutput, TeamDelete. Foreground Agent calls return inline; background Agent calls return a task ID and report via task-notification; persistent team workers report via team-notification (from= name). Do not poll workers through agents, predict results, overlap shared-file writes, or request unsolicited commits/pushes. Synthesize and verify evidence before reporting.`;
 var REMINDER_INTERVAL = 5;
 function coordinatorReminder(iteration = 1) {
   if (iteration <= 1 || (iteration - 1) % REMINDER_INTERVAL === 0) {
@@ -1529,6 +1739,7 @@ ${body}`)
     this.conversation.injectLongTermMemory(this.instructions, this.memoryContent, skills);
   }
   async *run() {
+    const telemetry = startAgentTelemetry(this.sessionId, this.client);
     this.restoreContext();
     const toolSchemas = this.registry.getAllSchemas(
       this.client.protocol ?? "anthropic",
@@ -1625,7 +1836,11 @@ ${body}`)
             return;
           }
           try {
-            const stream = this.client.stream(this.conversation, toolSchemas, this.abortSignal);
+            const stream = observeLlmStream(
+              this.client,
+              this.client.stream(this.conversation, toolSchemas, this.abortSignal),
+              telemetry
+            );
             for await (const event of stream) {
               if (this.abortSignal?.aborted) {
                 looping = false;
@@ -1803,7 +2018,7 @@ ${body}`)
             );
           }
           if (toolUses.length > 0) {
-            const results = await this.executeTools(toolUses);
+            const results = await this.executeTools(toolUses, telemetry);
             for (const r of results) {
               yield r;
             }
@@ -1887,7 +2102,11 @@ ${body}`)
         }
       }
     } finally {
-      await this.fireLifecycle("session_end");
+      try {
+        await this.fireLifecycle("session_end");
+      } finally {
+        endAgentTelemetry(telemetry, this.abortSignal?.aborted ? "interrupted" : "completed");
+      }
     }
   }
   // Fire a lifecycle hook event and queue any non-empty hook output as a
@@ -1926,13 +2145,14 @@ ${body}`)
       this.abortSignal?.addEventListener("abort", onAbort, { once: true });
     });
   }
-  async executeTools(toolUses) {
+  async executeTools(toolUses, telemetry) {
     const events = [];
     const batches = this.partitionToolCalls(toolUses);
     for (const batch of batches) {
       const batchEvents = await this.executeBatch(
         batch.blocks,
-        batch.concurrent && batch.blocks.length > 1
+        batch.concurrent && batch.blocks.length > 1,
+        telemetry
       );
       events.push(...batchEvents);
     }
@@ -1954,16 +2174,20 @@ ${body}`)
   // executeBatch runs a set of tool calls through permission checks, hooks,
   // and the streaming executor. When parallel is true all calls run
   // concurrently; otherwise they run one at a time.
-  async executeBatch(toolUses, parallel) {
+  async executeBatch(toolUses, parallel, telemetry) {
     const events = [];
-    const executor = new StreamingExecutor(this.registry, {
-      workDir: this.workDir,
-      abortSignal: this.abortSignal,
-      fileHistory: this.fileHistory,
-      fileStateCache: this.fileStateCache,
-      permissionChecker: this.checker,
-      onPermissionRequest: this.onPermissionRequest
-    });
+    const executor = new StreamingExecutor(
+      this.registry,
+      {
+        workDir: this.workDir,
+        abortSignal: this.abortSignal,
+        fileHistory: this.fileHistory,
+        fileStateCache: this.fileStateCache,
+        permissionChecker: this.checker,
+        onPermissionRequest: this.onPermissionRequest
+      },
+      telemetry
+    );
     for (const tu of toolUses) {
       if (this.abortSignal?.aborted) {
         events.push({
@@ -2050,7 +2274,12 @@ ${body}`)
       if (decision.effect === "ask" && this.onPermissionRequest) {
         let response;
         try {
-          response = await this.onPermissionRequest(tu.toolName, tu.arguments, decision);
+          response = await this.onPermissionRequest(
+            tu.toolName,
+            tu.arguments,
+            decision,
+            tu.toolUseId
+          );
           if (response === "allowAlways" && !this.abortSignal?.aborted) {
             this.checker.allowAlways(tu.toolName, tu.arguments);
           }
@@ -2174,7 +2403,14 @@ function parseRetryAfter(header) {
 }
 
 export {
+  captureTelemetryError,
+  shutdownTelemetry,
+  registerLlmClient,
   StreamingExecutor,
+  SUMMARY_INSTRUCTIONS,
+  buildSummaryInstructions,
+  buildSummaryPrompt,
+  buildCompactionSummaryMessage,
   ConversationManager,
   COMPACT_BOUNDARY,
   toolUsesToRecords,

package/dist/lib/{chunk-FZ4Y6MBN.js → chunk-BCBD34D2.js}

@@ -3,7 +3,7 @@ import {
   asRecord,
   createChildLogger,
   strArg
-} from "./chunk-EY7HE52Q.js";
+} from "./chunk-3XCGUKGJ.js";
 
 // src/mcp/tool-wrapper.ts
 var log = createChildLogger({ module: "mcp" });

package/dist/lib/{chunk-A4MXZA5Q.js → chunk-CFYAZWDA.js}

@@ -1,21 +1,22 @@
 import {
   mcpCallPermissionContent
-} from "./chunk-FZ4Y6MBN.js";
+} from "./chunk-BCBD34D2.js";
 import {
   createChildLogger,
   isRecord,
   strArg
-} from "./chunk-EY7HE52Q.js";
+} from "./chunk-3XCGUKGJ.js";
 
 // src/permissions/checker.ts
 import { readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
-import { homedir, tmpdir } from "os";
+import { homedir as homedir2, tmpdir } from "os";
 import { join as join2, resolve as resolve2, dirname as dirname2 } from "path";
 import yaml from "js-yaml";
 import z, { parse } from "zod";
 
 // src/utils/paths.ts
 import { realpathSync } from "fs";
+import { homedir } from "os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
 function canonicalPath(path) {
   let current = resolve(path);
@@ -40,6 +41,10 @@ function isPathWithin(root, path) {
   const child = relative(root, path);
   return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
 }
+function compactPath(path) {
+  const home = homedir();
+  return path === home ? "~" : path.startsWith(`${home}/`) ? `~/${path.slice(home.length + 1)}` : path;
+}
 
 // src/permissions/checker.ts
 var log = createChildLogger({ module: "permissions" });
@@ -373,7 +378,7 @@ var RuleEngine = class {
   projectPath;
   cache = /* @__PURE__ */ new Map();
   constructor(workDir) {
-    this.userPath = join2(homedir(), ".swifty", "permissions.yaml");
+    this.userPath = join2(homedir2(), ".swifty", "permissions.yaml");
     this.projectPath = join2(workDir, ".swifty", "permissions.yaml");
   }
   // Read a single rules file; skips disk I/O and parsing on cache hit.
@@ -621,6 +626,7 @@ var PermissionChecker = class _PermissionChecker {
 export {
   canonicalPath,
   isPathWithin,
+  compactPath,
   extractContent,
   PathSandbox,
   evaluateRules,

package/dist/lib/{chunk-4MDCRPVV.js → chunk-FODSMOWP.js}

@@ -1,6 +1,10 @@
 import {
   normalizeToolResultContentBlock
 } from "./chunk-XT67KGWE.js";
+import {
+  MCP_TOOL_PREFIX,
+  isMcpToolLike
+} from "./chunk-BCBD34D2.js";
 import {
   AuthenticationError,
   ContextTooLongError,
@@ -17,11 +21,7 @@ import {
   thinkingBudgetForLevel,
   toAnthropicThinkingEffort,
   toReasoningEffort
-} from "./chunk-OQIQOU5S.js";
-import {
-  MCP_TOOL_PREFIX,
-  isMcpToolLike
-} from "./chunk-FZ4Y6MBN.js";
+} from "./chunk-3OFLDUAW.js";
 import {
   asErrorString,
   asRecord,
@@ -30,7 +30,7 @@ import {
   createChildLogger,
   isRecord,
   strArg
-} from "./chunk-EY7HE52Q.js";
+} from "./chunk-3XCGUKGJ.js";
 
 // src/llm/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";

package/dist/lib/chunk-GTHYQZRL.js

@@ -0,0 +1,31 @@
+// src/version.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var PackageJsonSchema = z.object({
+  version: z.string()
+});
+function resolveVersion() {
+  if (true) {
+    return "0.0.33";
+  }
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  for (const levels of ["..", "../.."]) {
+    const candidate = path.resolve(here, levels, "package.json");
+    try {
+      const raw = JSON.parse(readFileSync(candidate, "utf-8"));
+      const parsed = PackageJsonSchema.safeParse(raw);
+      if (parsed.success) {
+        return parsed.data.version;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Could not resolve package version");
+}
+var version = resolveVersion();
+
+export {
+  version
+};

package/dist/lib/{chunk-EWE5IWZE.js → chunk-LDWFI6MR.js}

@@ -21,6 +21,15 @@ var ToolRegistry = class {
   register(tool) {
     this.tools.set(tool.name, tool);
   }
+  /**
+   * Removes a tool and forgets its discovery state, so a re-registered tool
+   * with the same name starts deferred again. Used by /mcp reload to drop
+   * tools of servers that disappeared from the config.
+   */
+  unregister(name) {
+    this.tools.delete(name);
+    this.discovered.delete(name);
+  }
   get(name) {
     return this.tools.get(name);
   }
@@ -124,13 +133,15 @@ var ToolRegistry = class {
 };
 
 // src/subagent/tool-filter.ts
-var MAIN_AGENT_ONLY_TOOLS = /* @__PURE__ */ new Set(["ComputerUse"]);
+var MAIN_AGENT_ONLY_TOOLS = /* @__PURE__ */ new Set([
+  "ComputerUse",
+  "AskUserQuestion",
+  "ExitPlanMode"
+]);
 var SUBAGENT_DISALLOWED_TOOLS = /* @__PURE__ */ new Set([
-  "ExitPlanMode",
+  ...MAIN_AGENT_ONLY_TOOLS,
   "Agent",
   // Prevents recursive spawning of subagents
-  "AskUserQuestion",
-  ...MAIN_AGENT_ONLY_TOOLS,
   "TaskStop"
 ]);
 var TEAMMATE_DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["TeamCreate", "TeamDelete"]);

package/dist/lib/{chunk-OEPCNATU.js → chunk-TJLAJGG4.js}

@@ -11,7 +11,7 @@ import {
   getThinkingLevel,
   resolveAPIKey,
   toReasoningEffort
-} from "./chunk-OQIQOU5S.js";
+} from "./chunk-3OFLDUAW.js";
 import {
   asRecord,
   asString,
@@ -19,7 +19,7 @@ import {
   createChildLogger,
   isRecord,
   strArg
-} from "./chunk-EY7HE52Q.js";
+} from "./chunk-3XCGUKGJ.js";
 
 // src/llm/openai.ts
 import OpenAI from "openai";