@deepstrike/sdk 0.1.4 → 0.1.7

package/README.md

@@ -16,13 +16,15 @@ Pre-built native addons are available for the following platforms:
 
 | Platform | Package |
 | -------- | ------- |
-| Linux x64 (glibc) | `@deepstrike/core-linux-x64-gnu` |
-| Linux ARM64 (glibc) | `@deepstrike/core-linux-arm64-gnu` |
 | macOS x64 | `@deepstrike/core-darwin-x64` |
 | macOS ARM64 (Apple Silicon) | `@deepstrike/core-darwin-arm64` |
+| Linux x64 (glibc) | `@deepstrike/core-linux-x64-gnu` |
+| Linux x64 (musl / Alpine) | `@deepstrike/core-linux-x64-musl` |
+| Linux ARM64 (glibc) | `@deepstrike/core-linux-arm64-gnu` |
+| Linux ARM64 (musl / Alpine) | `@deepstrike/core-linux-arm64-musl` |
 | Windows x64 | `@deepstrike/core-win32-x64-msvc` |
 
-The correct platform package is selected and installed automatically via `optionalDependencies`.
+The correct platform package is selected and installed automatically via `optionalDependencies`. No postinstall download is required.
 
 > **Note:** `@deepstrike/core` is the low-level native addon package and is not intended for direct use. It is an internal dependency automatically managed by `@deepstrike/sdk`. Direct installation is only relevant when building from Rust source.
 
@@ -33,11 +35,7 @@ The correct platform package is selected and installed automatically via `option
 ```typescript
 import { Agent, OpenAIProvider, tool } from "@deepstrike/sdk"
 
-const provider = new OpenAIProvider({
-  apiKey: process.env.OPENAI_API_KEY,
-  model: "gpt-5-mini",
-  baseUrl: "https://api.openai.com/v1",
-})
+const provider = new OpenAIProvider(process.env.OPENAI_API_KEY!, "gpt-5-mini")
 
 const add = tool("add", "Add two numbers.", {
   type: "object",
@@ -49,7 +47,7 @@ const agent = new Agent(provider, { maxTokens: 4096 })
 agent.register(add)
 
 const result = await agent.run("What is 17 + 28?")
-console.log(result) // "done in 2 turns (completed)"
+console.log(result)
 ```
 
 Streaming:
@@ -106,9 +104,8 @@ const agent = new Agent(provider, {
 import { tool, readFile } from "@deepstrike/sdk"
 
 agent.register(tool("search", "Search.", schema, async (args) => ...))
-agent.register(readFile())   // built-in: read files from disk
+agent.register(readFile)     // built-in: read files from disk
 agent.unregister("search")
-agent.blockTool("bash")      // governance veto
 ```
 
 ---
@@ -211,6 +208,9 @@ const gov = new Governance("allow")
 gov.addPermissionRule("danger.*", "deny")
 gov.blockTool("rm_rf")
 gov.setRateLimit("api_call", 10, 60_000)
+gov.requireParam("write_file", "path")
+gov.allowParamValues("set_mode", "mode", ["read", "write"])
+gov.limitParamRange("sleep", "seconds", 0, 10)
 
 const agent = new Agent(provider, { maxTokens: 4096, governance: gov })
 // Every tool call goes through: Permission → Veto → RateLimit → Constraint → Audit
@@ -224,12 +224,10 @@ const agent = new Agent(provider, { maxTokens: 4096, governance: gov })
 import { SignalGateway, ScheduledPrompt } from "@deepstrike/sdk"
 
 const gw = new SignalGateway()
-const rx = gw.subscribe()
-
 gw.schedule(new ScheduledPrompt("standup", Date.now() + 3600_000))
-gw.ingest({ kind: "interrupt", payload: {}, priority: 10 })
+gw.ingest({ kind: "interrupt", urgency: "critical", payload: {} })
 
-const agent = new Agent(provider, { maxTokens: 4096, signalSource: rx })
+const agent = new Agent(provider, { maxTokens: 4096, signalSource: gw })
 // kind="interrupt" → immediately stops the running agent
 
 agent.interrupt() // also works directly

package/dist/agent.d.ts

@@ -34,11 +34,12 @@ export interface AgentOptions {
      */
     agentId?: string;
     /**
-     * Kernel Governance instance (from `@deepstrike/core`) or any object implementing
+     * SDK Governance instance or any object implementing
      * `evaluate(toolName: string, argsJson: string): { kind: string; reason?: string; retryAfterMs?: number }`.
      * When provided, every tool call is evaluated through the full pipeline.
      */
     governance?: {
+        setTime?(nowMs: bigint): void;
         evaluate(toolName: string, argsJson: string): {
             kind: string;
             reason?: string;

package/dist/agent.js

@@ -1,12 +1,6 @@
 import { executeTools } from "./tools/index.js";
 import { readSkillFile, scanSkillDir } from "./skills/loader.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function loadKernel() {
-    const mod = await import("@deepstrike/core");
-    // CJS modules imported via ESM dynamic import expose exports under `.default`
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return mod.default ?? mod;
-}
+import { getKernel } from "./kernel.js";
 export class Agent {
     provider;
     options;
@@ -66,12 +60,12 @@ export class Agent {
         if (this.knowledgeSource) {
             await this.knowledgeSource.init();
         }
-        const kernel = await loadKernel();
+        const kernel = getKernel();
         const ext = { ...this.extensions, ...(extensions ?? {}) };
         const sm = new kernel.LoopStateMachine({
             maxTokens: this.options.maxTokens,
             maxTurns: this.options.maxTurns ?? 25,
-            timeoutMs: this.options.timeoutMs,
+            timeoutMs: this.options.timeoutMs === undefined ? undefined : BigInt(this.options.timeoutMs),
         });
         // Per-run SignalRouter — dedup state never leaks between runs.
         const router = new kernel.SignalRouter(256);
@@ -123,16 +117,14 @@ export class Agent {
             if (this.signalSource) {
                 const sig = await this.signalSource.nextSignal();
                 if (sig) {
-                    const sigAny = sig;
                     const kernelSig = {
                         id: crypto.randomUUID(),
-                        source: sigAny.source ?? "custom",
-                        signalType: sigAny.signalType ?? "event",
-                        urgency: sigAny.urgency
-                            ?? (sig.kind === "interrupt" ? "critical" : "normal"),
-                        summary: String(sig.payload?.goal ?? sig.kind),
+                        source: sig.source ?? "custom",
+                        signalType: sig.signalType ?? "event",
+                        urgency: normalizeSignalUrgency(sig),
+                        summary: String(sig.payload?.goal ?? sig.kind ?? "signal"),
                         payload: JSON.stringify(sig.payload ?? {}),
-                        dedupeKey: sigAny.dedupeKey ?? null,
+                        dedupeKey: sig.dedupeKey,
                         timestampMs: Date.now(),
                     };
                     const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
@@ -193,6 +185,7 @@ export class Agent {
                 const deniedResults = [];
                 for (const c of allCalls) {
                     if (this.options.governance) {
+                        this.options.governance.setTime?.(BigInt(Date.now()));
                         const verdict = this.options.governance.evaluate(c.name, c.arguments);
                         if (verdict.kind === "deny") {
                             const msg = `permission denied: ${c.name} — ${verdict.reason ?? ""}`;
@@ -270,7 +263,7 @@ export class Agent {
         const result = action.result;
         this._turn = sm.turn;
         this._pressure = sm.pressure();
-        const status = result?.termination === "completed" ? "success" : (result?.termination ?? "error");
+        const status = result?.termination ?? "error";
         const iterations = result ? Math.max(1, result.turnsUsed) : 0;
         if (this.options.dreamStore && this.options.agentId && sessionMsgs.length > 1) {
             try {
@@ -304,7 +297,7 @@ export class Agent {
     async dream(agentId, nowMs = Date.now()) {
         if (!this.dreamStore)
             throw new Error("dreamStore not configured on AgentOptions");
-        const kernel = await loadKernel();
+        const kernel = getKernel();
         const sessions = await this.dreamStore.loadSessions(agentId);
         const existingMemories = await this.dreamStore.loadMemories(agentId);
         if (!sessions.length) {
@@ -378,3 +371,6 @@ function tryParseJson(s) {
         return null;
     }
 }
+function normalizeSignalUrgency(sig) {
+    return sig.urgency;
+}

package/dist/governance.d.ts

@@ -0,0 +1,17 @@
+import type { GovernanceVerdict } from "./kernel.js";
+type GovernanceDefaultAction = "allow" | "deny" | "ask_user";
+type GovernanceRuleAction = "allow" | "deny" | "ask_user";
+export declare class Governance {
+    private readonly inner;
+    constructor(defaultAction?: GovernanceDefaultAction);
+    setIdentity(agentId: string, sessionId: string): void;
+    addPermissionRule(pattern: string, action: GovernanceRuleAction): void;
+    blockTool(name: string): void;
+    setRateLimit(toolName: string, maxCalls: number, windowMs: number): void;
+    requireParam(toolName: string, paramPath: string): void;
+    allowParamValues(toolName: string, paramPath: string, allowedValues: string[]): void;
+    limitParamRange(toolName: string, paramPath: string, min?: number, max?: number): void;
+    setTime(nowMs: number | bigint): void;
+    evaluate(toolName: string, argsJson: string): GovernanceVerdict;
+}
+export type { GovernanceVerdict };

package/dist/governance.js

@@ -0,0 +1,34 @@
+import { getKernel } from "./kernel.js";
+export class Governance {
+    inner;
+    constructor(defaultAction = "allow") {
+        this.inner = new (getKernel().Governance)(defaultAction);
+    }
+    setIdentity(agentId, sessionId) {
+        this.inner.setIdentity(agentId, sessionId);
+    }
+    addPermissionRule(pattern, action) {
+        this.inner.addPermissionRule(pattern, action);
+    }
+    blockTool(name) {
+        this.inner.blockTool(name);
+    }
+    setRateLimit(toolName, maxCalls, windowMs) {
+        this.inner.setRateLimit(toolName, maxCalls, BigInt(windowMs));
+    }
+    requireParam(toolName, paramPath) {
+        this.inner.requireParam(toolName, paramPath);
+    }
+    allowParamValues(toolName, paramPath, allowedValues) {
+        this.inner.allowParamValues(toolName, paramPath, allowedValues);
+    }
+    limitParamRange(toolName, paramPath, min, max) {
+        this.inner.limitParamRange(toolName, paramPath, min, max);
+    }
+    setTime(nowMs) {
+        this.inner.setTime(typeof nowMs === "bigint" ? nowMs : BigInt(nowMs));
+    }
+    evaluate(toolName, argsJson) {
+        return this.inner.evaluate(toolName, argsJson);
+    }
+}

package/dist/harness/harness.d.ts

@@ -25,6 +25,38 @@ export interface HarnessOutcome {
     feedback?: string;
     details?: CriterionResult[];
 }
+export interface Verdict {
+    passed: boolean;
+    overallScore: number;
+    feedback: string;
+    details: CriterionResult[];
+}
+export type HarnessEvent = {
+    type: "token";
+    text: string;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+} | {
+    type: "tool_result";
+    callId: string;
+    content: string;
+    isError: boolean;
+} | {
+    type: "supervising";
+} | {
+    type: "revising";
+    verdict: Verdict;
+} | {
+    type: "done";
+    verdict: Verdict;
+    iterations: number;
+    totalTokens: number;
+    status: string;
+} | {
+    type: "max_attempts_reached";
+};
 export interface QualityGate {
     evaluate(request: HarnessRequest, outcome: HarnessOutcome): Promise<boolean>;
 }
@@ -50,5 +82,5 @@ export declare class HarnessLoop {
     private maxAttempts;
     private skillDir?;
     constructor(agent: Agent, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
-    run(request: HarnessRequest): Promise<HarnessOutcome>;
+    runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
 }

package/dist/harness/harness.js

@@ -1,11 +1,6 @@
 import { writeFile } from "fs/promises";
 import path from "path";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function loadKernel() {
-    const mod = await import("@deepstrike/core");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return mod.default ?? mod;
-}
+import { getKernel } from "../kernel.js";
 async function runOnce(agent, req) {
     let text = "";
     let done;
@@ -56,15 +51,44 @@ export class HarnessLoop {
         this.maxAttempts = options.maxAttempts ?? 3;
         this.skillDir = options.skillDir;
     }
-    async run(request) {
-        const kernel = await loadKernel();
+    async *runStreaming(request) {
+        const kernel = getKernel();
         const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
         const criteria = request.criteria ?? [];
-        let outcome = { result: "", passed: false, iterations: 0, totalTokens: 0, status: "error" };
+        // history tracks the full conversation; agent sees only the current goal message
+        // but we inject feedback as user messages to guide revision without discarding prior output
         let currentGoal = request.goal;
+        let lastIterations = 0;
+        let lastTotalTokens = 0;
+        let lastStatus = "error";
+        let lastResult = "";
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
-            outcome = await runOnce(this.agent, { ...request, goal: currentGoal });
-            const evalAction = pipeline.feedOutcome(request.goal, criteria, outcome.result, attempt);
+            // Stream agent output directly to caller
+            for await (const evt of this.agent.runStreaming(currentGoal, criteria.map(c => c.text), request.extensions)) {
+                if (evt.type === "text_delta") {
+                    lastResult += evt.delta;
+                    yield { type: "token", text: evt.delta };
+                }
+                else if (evt.type === "tool_call") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tc = evt;
+                    yield { type: "tool_call", id: tc.id, name: tc.name };
+                }
+                else if (evt.type === "tool_result") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tr = evt;
+                    yield { type: "tool_result", callId: tr.callId, content: tr.content, isError: tr.isError };
+                }
+                else if (evt.type === "done") {
+                    const d = evt;
+                    lastIterations = d.iterations;
+                    lastTotalTokens = d.totalTokens;
+                    lastStatus = d.status;
+                }
+            }
+            // Checkpoint: evaluator judges the completed output
+            yield { type: "supervising" };
+            const evalAction = pipeline.feedOutcome(request.goal, criteria, lastResult, attempt);
             if (evalAction.kind !== "evaluate")
                 break;
             let evalText = "";
@@ -75,26 +99,29 @@ export class HarnessLoop {
             const doneAction = pipeline.feedEvalResult(evalText);
             if (doneAction.kind !== "done")
                 break;
-            outcome = {
-                ...outcome,
+            const verdict = {
                 passed: doneAction.passed ?? false,
-                overallScore: doneAction.overallScore ?? undefined,
-                feedback: doneAction.feedback ?? undefined,
-                details: doneAction.details ?? undefined,
+                overallScore: doneAction.overallScore ?? 0,
+                feedback: doneAction.feedback ?? "",
+                details: doneAction.details ?? [],
             };
-            if (doneAction.passed) {
-                if (doneAction.skill_candidate && this.skillDir) {
-                    const { name, description, whenToUse, content } = doneAction.skill_candidate;
+            if (verdict.passed) {
+                if (doneAction.skillCandidate && this.skillDir) {
+                    const { name, description, whenToUse, content } = doneAction.skillCandidate;
                     const fm = ["---", `name: ${name}`, `description: ${description}`,
                         whenToUse ? `when_to_use: ${whenToUse}` : null, "---", ""]
                         .filter(Boolean).join("\n");
                     await writeFile(path.join(this.skillDir, `${name}.md`), fm + content, "utf8");
                 }
-                return outcome;
+                yield { type: "done", verdict, iterations: lastIterations, totalTokens: lastTotalTokens, status: lastStatus };
+                return;
             }
-            currentGoal = `${request.goal}\n\n[Previous attempt ${attempt} failed: ${doneAction.feedback}]`;
+            yield { type: "revising", verdict };
+            // Inject feedback as next turn's goal — agent sees its prior output + evaluator notes
+            currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
+            lastResult = "";
             pipeline.reset();
         }
-        return outcome;
+        yield { type: "max_attempts_reached" };
     }
 }

package/dist/index.d.ts

@@ -18,6 +18,6 @@ export { SignalGateway } from "./signals/gateway.js";
 export type { RuntimeSignal, SignalSource } from "./signals/types.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export type { PermissionDecision, Permission } from "./safety/permissions.js";
-export declare const Governance: typeof import("@deepstrike/core").Governance;
-export type { GovernanceVerdictObj as GovernanceVerdict } from "@deepstrike/core";
+export { Governance } from "./governance.js";
+export type { GovernanceVerdict } from "./governance.js";
 export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, } from "./types.js";

package/dist/index.js

@@ -10,10 +10,4 @@ export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harne
 export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
-// Kernel Governance — full pipeline (Permission → Veto → RateLimit → Constraint → Audit)
-// @deepstrike/core is a CJS native addon; static ESM named re-export doesn't work,
-// so we load it via createRequire and re-export with proper types preserved.
-import { createRequire } from "module";
-const _cjsRequire = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const Governance = _cjsRequire("@deepstrike/core").Governance;
+export { Governance } from "./governance.js";

package/dist/kernel.d.ts

@@ -0,0 +1,149 @@
+import type { Message, ToolCall, ToolResult, ToolSchema } from "./types.js";
+import type { SkillMetadata } from "./skills/loader.js";
+export interface GovernanceVerdict {
+    kind: "allow" | "deny" | "rate_limited" | "ask_user";
+    reason?: string;
+    retryAfterMs?: number;
+}
+export interface GovernanceInstance {
+    setIdentity(agentId: string, sessionId: string): void;
+    addPermissionRule(pattern: string, action: "allow" | "deny" | "ask_user"): void;
+    blockTool(name: string): void;
+    setRateLimit(toolName: string, maxCalls: number, windowMs: bigint): void;
+    requireParam(toolName: string, paramPath: string): void;
+    allowParamValues(toolName: string, paramPath: string, allowedValues: string[]): void;
+    limitParamRange(toolName: string, paramPath: string, min?: number, max?: number): void;
+    setTime(nowMs: bigint): void;
+    evaluate(toolName: string, argsJson: string): GovernanceVerdict;
+}
+export interface RuntimeSignal {
+    id: string;
+    source: "cron" | "gateway" | "heartbeat" | "custom";
+    signalType: "event" | "job" | "alert";
+    urgency: "low" | "normal" | "high" | "critical";
+    summary: string;
+    payload: string;
+    dedupeKey?: string;
+    timestampMs: number;
+}
+export interface LoopAction {
+    kind: "call_llm" | "execute_tools" | "done";
+    messages?: Message[];
+    tools?: ToolSchema[];
+    calls?: ToolCall[];
+    result?: {
+        termination: string;
+        turnsUsed: number;
+        totalTokensUsed: bigint;
+    };
+}
+interface LoopObservation {
+    kind: "compressed";
+    action?: string;
+    rhoAfter?: number;
+}
+interface LoopStateMachineInstance {
+    setAvailableSkills(skills: SkillMetadata[]): void;
+    setMemoryEnabled(enabled: boolean): void;
+    setKnowledgeEnabled(enabled: boolean): void;
+    addSystemMessage(content: string, tokens: number): void;
+    addMemoryMessage(content: string, tokens: number): void;
+    setTools(tools: ToolSchema[]): void;
+    start(task: {
+        goal: string;
+        criteria: string[];
+    }): LoopAction;
+    feedLlmResponse(message: Message): LoopAction;
+    feedToolResults(results: ToolResult[]): LoopAction;
+    feedTimeout(): LoopAction;
+    isTerminal(): boolean;
+    readonly turn: number;
+    pressure(): number;
+    takeObservations(): LoopObservation[];
+}
+interface SignalRouterInstance {
+    ingest(signal: RuntimeSignal, isRunning: boolean): string;
+    next(): RuntimeSignal | null;
+}
+interface NativeCriterion {
+    text: string;
+    required: boolean;
+    weight?: number;
+}
+interface EvalPipelineAction {
+    kind: "evaluate" | "done";
+    messages?: Message[];
+    passed?: boolean;
+    overallScore?: number;
+    feedback?: string;
+    details?: Array<{
+        criterion: string;
+        passed: boolean;
+        score: number;
+        feedback: string;
+    }>;
+    skillCandidate?: {
+        name: string;
+        description: string;
+        whenToUse?: string;
+        content: string;
+    };
+}
+interface EvalPipelineInstance {
+    feedOutcome(goal: string, criteria: NativeCriterion[], result: string, attempt: number): EvalPipelineAction;
+    feedEvalResult(content: string): EvalPipelineAction;
+    reset(): void;
+}
+interface IdlePipelineAction {
+    kind: "synthesize_insights" | "commit_memories" | "noop" | "aborted";
+    messages?: Message[];
+    curationResult?: {
+        toAdd?: Array<{
+            text: string;
+            score: number;
+            metadata: string;
+        }>;
+        toRemoveIndices?: number[];
+        stats?: {
+            insightsProcessed?: number;
+            duplicatesRemoved?: number;
+            conflictsResolved?: number;
+            entriesAdded?: number;
+        };
+    };
+    runResult?: {
+        sessionsProcessed: number;
+        insightsExtracted: number;
+    };
+}
+interface IdlePipelineInstance {
+    feedTrigger(sessions: Array<{
+        sessionId: string;
+        agentId: string;
+        messages: Message[];
+        metadata: string;
+        createdAtMs: number;
+        updatedAtMs: number;
+    }>, existingMemories: Array<{
+        text: string;
+        score: number;
+        metadata: string;
+    }>, nowMs: number): IdlePipelineAction;
+    feedSynthesisResult(content: string): IdlePipelineAction;
+}
+interface KernelModule {
+    Governance: new (defaultAction?: "allow" | "deny" | "ask_user") => GovernanceInstance;
+    LoopStateMachine: new (policy: {
+        maxTokens: number;
+        maxTurns?: number;
+        maxTotalTokens?: bigint;
+        timeoutMs?: bigint;
+    }) => LoopStateMachineInstance;
+    SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
+    EvalPipeline: new (options?: {
+        extractSkillOnPass?: boolean;
+    }) => EvalPipelineInstance;
+    IdlePipeline: new (agentId: string) => IdlePipelineInstance;
+}
+export declare function getKernel(): KernelModule;
+export {};

package/dist/kernel.js

@@ -0,0 +1,9 @@
+import { createRequire } from "module";
+const cjsRequire = createRequire(import.meta.url);
+let cachedKernel;
+export function getKernel() {
+    if (!cachedKernel) {
+        cachedKernel = cjsRequire("@deepstrike/core");
+    }
+    return cachedKernel;
+}

package/dist/memory/protocols.d.ts

@@ -1,5 +1,6 @@
+import type { Message } from "../types.js";
 export interface SessionMessage {
-    role: string;
+    role: Message["role"];
     content: string;
     tokenCount?: number;
     toolCalls?: Array<{

package/dist/memory/protocols.js

@@ -1,2 +1 @@
-// ─── Dream / idle-pipeline types ─────────────────────────────────────────────
 export {};

package/dist/safety/permissions.d.ts

@@ -24,6 +24,7 @@ export declare class PermissionManager {
         requiresApproval?: boolean;
         note?: string;
     }): this;
+    grantWithApproval(resource: string, action: string, note?: string): this;
     revoke(resource: string, action: string, note?: string): this;
     private matchPermission;
     evaluate(resource: string, action: string): PermissionDecision;

package/dist/safety/permissions.js

@@ -19,6 +19,9 @@ export class PermissionManager {
         });
         return this;
     }
+    grantWithApproval(resource, action, note = "") {
+        return this.grant(resource, action, { requiresApproval: true, note });
+    }
     revoke(resource, action, note = "") {
         const key = `${resource}:${action}`;
         this.permissions.set(key, { tool: resource, action, allowed: false, requiresApproval: false, note });

package/dist/signals/gateway.js

@@ -33,6 +33,10 @@ export class SignalGateway {
             this.timers.delete(key);
             this.emit({
                 kind: "scheduled",
+                source: "cron",
+                signalType: "job",
+                urgency: "normal",
+                dedupeKey: key,
                 payload: { goal: prompt.goal, criteria: prompt.criteria, runAtMs: prompt.runAtMs, ...prompt.metadata },
             });
         };

package/dist/signals/scheduled.js

@@ -12,6 +12,10 @@ export class ScheduledPrompt {
     toSignal() {
         return {
             kind: "scheduled",
+            source: "cron",
+            signalType: "job",
+            urgency: "normal",
+            dedupeKey: `cron:${this.goal}:${this.runAtMs}`,
             payload: { goal: this.goal, criteria: this.criteria, runAtMs: this.runAtMs, ...this.metadata },
         };
     }

package/dist/signals/types.d.ts

@@ -1,6 +1,15 @@
+export type RuntimeSignalSource = "cron" | "gateway" | "heartbeat" | "custom";
+export type RuntimeSignalType = "event" | "job" | "alert";
+export type RuntimeSignalUrgency = "low" | "normal" | "high" | "critical";
 export interface RuntimeSignal {
-    kind: "interrupt" | "scheduled" | "external";
+    source: RuntimeSignalSource;
+    signalType: RuntimeSignalType;
+    urgency: RuntimeSignalUrgency;
     payload: Record<string, unknown>;
+    dedupeKey?: string;
+    /** @deprecated Use source/signalType/urgency directly. */
+    kind?: "interrupt" | "scheduled" | "external";
+    /** @deprecated Prefer explicit `urgency`. */
     priority?: number;
 }
 export interface SignalSource {

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist", "README.md"],
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.4",
+    "@deepstrike/core": "0.1.7",
     "openai": "^4.77.0"
   },
   "devDependencies": {