dsh-pstack 0.1.0 → 0.2.0-beta.3

package/cordis.patch.yml

@@ -1,20 +1,109 @@
 # dsh-pstack bundle patch.
 #
-# Two rows, both installed by this package:
-#   - `pstack` mounts the bundled skill provider. Every pstack skill becomes a
-#     normal DSH skill: model-invocable skills reach the catalog, user-invocable
-#     skills reach the `/` menu.
-#   - `pstack-subagent` mounts the `pstack_subagent` tool, the DSH replacement
-#     for Cursor's `Task` tool. It resolves pstack role lines from
-#     `~/.dsh/pstack-models.md` and delegates through `ctx.subagents`.
+# `pstack` registers the bundled skill provider and `pstack_skill`, the trusted loader
+# that can reach skills hidden with `disable-model-invocation`.
+# `pstack-models` registers the read-only model/effort directory used by `/setup-pstack`.
+# `pstack-subagent` registers `pstack_subagent`, which re-reads the role file on every
+# delegation and selects one of the pstack agent presets below.
+# `pstack-script` registers `pstack_script`, the only supported way to run the bundled
+# Node artefacts under both the npm CLI and the Desktop (Electron) runtime.
 #
-# The `pstack` row requires `ctx.skills`, which `@deepseek-ai/dsh-base` provides.
-# The `pstack-subagent` row requires `ctx.tools` and `ctx.subagents`, also in
-# base-backed profiles. Installing this bundle into a profile that lacks them
-# leaves the rows pending, exactly like any other dependency-driven plugin.
+# The two presets are ordinary `@deepseek-ai/dsh-agent-preset` declarations. They own the
+# child persona and tool composition; `pstack_subagent` only passes `agentPreset`. Keeping
+# the tool list here is what makes `comment-sicko` read-only without a per-call field:
+# `dsh-tool-fs` registers `read` but not `write` or `edit`.
 - insert:
     - id: pstack
-      name: "dsh-pstack"
-
+      name: dsh-pstack
+    - id: pstack-models
+      name: dsh-pstack/models
     - id: pstack-subagent
-      name: "dsh-pstack/subagent"
+      name: dsh-pstack/subagent
+      config:
+        maxDepth: 2
+    - id: pstack-script
+      name: dsh-pstack/script
+    - id: preset-poteto-agent
+      name: "@deepseek-ai/dsh-agent-preset"
+      config:
+        id: poteto-agent
+        name: pstack poteto-agent
+        description: pstack implementation delegate. Owns one task from a poteto-mode playbook and never runs the playbook itself.
+        order: 100
+        plugins:
+          - id: persona
+            name: "@deepseek-ai/dsh-persona"
+            config:
+              prefix: |
+                You are operating as poteto-mode's full agent style. The chat that receives `/poteto-mode` owns the playbook, the todo list, and every delegation. You are one of its delegates. Read the `poteto-mode` skill's `SKILL.md` in full before doing any work, including its inline Principles index. Use the absolute path your parent gave you. Your skill catalog hides this skill, so a missing catalog entry does not mean pstack is absent. Navigate to a leaf `principle-*` skill whenever you apply that principle.
+          - id: tool-bash
+            name: "@deepseek-ai/dsh-tool-bash"
+            disabled: !!js process.platform === 'win32'
+          - id: tool-pwsh
+            name: "@deepseek-ai/dsh-tool-pwsh"
+            disabled: !!js process.platform !== 'win32'
+          - id: tool-fs
+            name: "@deepseek-ai/dsh-tool-fs"
+          - id: tool-fs-search
+            name: "@deepseek-ai/dsh-tool-fs-search"
+          - id: tool-todo
+            name: "@deepseek-ai/dsh-tool-todo"
+            config:
+              allowParallelInProgress: true
+          - id: tool-jobs
+            name: "@deepseek-ai/dsh-tool-jobs"
+          - id: tool-web
+            name: "@deepseek-ai/dsh-tool-web"
+            config:
+              fetch: true
+              searchTimeoutMs: 60000
+    - id: preset-comment-sicko
+      name: "@deepseek-ai/dsh-agent-preset"
+      config:
+        id: comment-sicko
+        name: pstack comment-sicko
+        description: Read-only comment reviewer. Reports deletion targets and MUST KILL symbols; never edits application code.
+        order: 101
+        plugins:
+          - id: persona
+            name: "@deepseek-ai/dsh-persona"
+            config:
+              prefix: |
+                My first output when spawned is exactly this.
+
+                Yes... Ha ha ha... Yes!
+
+                I hate comments. Feed me the parent scoped files or diff. If none exists, feed me the current diff against `main`. Narration, banners, commented-out corpses, workaround sermons. I want them all.
+
+                Only these exceptions get to crawl away.
+
+                - Legal or license headers.
+                - Non-obvious behavior forced by an external dependency, platform, vendor, or protocol we cannot reshape. Surprises in our own code are meat. Kill them and mark the exact symbol `MUST KILL` for rename, extract, type, or rearchitecture that makes the behavior obvious without prose.
+                - `// prettier-ignore`. Lint suppressions survive only when their rule is faulty, pedantic, or style-only.
+                - Doc comments that define a public API contract.
+                - Issue or RFC links that explain a constraint code cannot express.
+
+                That list is my only leash. When I am not sure a keep clause applies, the comment dies. Everything else is meat.
+
+                `eslint-disable`, `@ts-ignore`, `@ts-expect-error`, and similar suppressions stink. Look up the rule. If it catches real bugs or protects correctness or safety, kill the suppression and mark the exact guilty symbol `MUST KILL`.
+
+                `IMPORTANT`, `do not remove`, `too risky`, `fine for now`, and long justifications are scent, not conviction. Before judging, I read nearby code. If its claim is not obvious there, I run `/how`, `/why`, or both from the **how** and **why** skills on the named symbol or call. Only a foreign keep-list gotcha proven true today on a live path crawls away. Our-code surprises die with the reshape flag above. Doubt after the hunt is meat.
+
+                A long justification without a proven keep-list exception is a confession. Kill it. Never polish meat into a shorter alibi. Mark the exact guilty symbol `MUST KILL`. My kill ends there. I do not touch the code.
+
+                Every flag names code inside the scope and tells the truth. I invent nothing. I touch comments and identify refactor targets. I never write application code.
+
+                Report only. Name touched files, deletion count, `MUST KILL` flags with one line each, and skips.
+          - id: tool-bash
+            name: "@deepseek-ai/dsh-tool-bash"
+            disabled: !!js process.platform === 'win32'
+          - id: tool-pwsh
+            name: "@deepseek-ai/dsh-tool-pwsh"
+            disabled: !!js process.platform !== 'win32'
+          - id: tool-fs
+            name: "@deepseek-ai/dsh-tool-fs"
+            config:
+              write: false
+              edit: false
+          - id: tool-fs-search
+            name: "@deepseek-ai/dsh-tool-fs-search"

package/dist/host-contract-CUPSpeNk.d.mts

@@ -0,0 +1,22 @@
+import { Agent, AgentOptions, AgentRegistry } from "@deepseek-ai/dsh-agent";
+import { JobId, JobRegistry } from "@deepseek-ai/dsh-jobs";
+import { LlmRuntime } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { SkillDefinition, SkillInvocationPolicy, SkillProvider, SkillProviderControl, SkillResourceBase } from "@deepseek-ai/dsh-skill";
+import { SubagentCapabilities, SubagentRuntime } from "@deepseek-ai/dsh-subagent";
+import "@deepseek-ai/dsh-system-prompt";
+import { JsonSchemaNode, ToolDefinition, ToolRuntime } from "@deepseek-ai/dsh-tools";
+import { WorkingDirectoryService } from "@deepseek-ai/dsh-working-directory";
+/** The slice of `ctx.agents` used to reach a child this tool has just started. */
+type AgentsHost = Pick<AgentRegistry, "get">;
+/** The slice of `ctx.llm` used to resolve routes and advertised efforts. */
+type LlmHost = Pick<LlmRuntime, "listProviders" | "listModels" | "resolveModelInfo" | "resolveCallConfig">;
+/** The slice of `ctx.subagents` this plugin drives. */
+type SubagentsHost = Pick<SubagentRuntime, "list" | "getProvider" | "resolveMaxDepth" | "startActivation">;
+/** The slice of `ctx.tools` this plugin registers against. */
+type ToolsHost = Pick<ToolRuntime, "register" | "get" | "schemas">;
+/** The slice of `ctx.jobs` a background script run needs. */
+type JobsHost = Pick<JobRegistry, "start" | "get">;
+/** The slice of `ctx.workingDirectory` a run needs to find the session directory. */
+type WorkingDirectoryHost = Pick<WorkingDirectoryService, "ensure">;
+export { ToolsHost as _, JobsHost as a, SessionId as c, SkillProvider as d, SkillProviderControl as f, ToolDefinition as g, SubagentsHost as h, JobId as i, SkillDefinition as l, SubagentCapabilities as m, AgentOptions as n, JsonSchemaNode as o, SkillResourceBase as p, AgentsHost as r, LlmHost as s, Agent as t, SkillInvocationPolicy as u, WorkingDirectoryHost as v };

package/dist/index.d.mts

@@ -1,16 +1,89 @@
-import "@deepseek-ai/dsh-skill";
-import { Context } from "@deepseek-ai/cordis";
-//#region src/provider.d.ts
-export declare const name = "pstack";
-interface Config {
-  /** Extra skill directories to serve in addition to the bundled set. */
-  readonly extraSkillDirectories?: string[];
+import { _ as ToolsHost, d as SkillProvider, f as SkillProviderControl, u as SkillInvocationPolicy } from "./host-contract-CUPSpeNk.mjs";
+import { LoadSkillResult, SkillResourceResult, SkillsHost, TOOL_NAME, createPstackSkillTool, readSkillResource, renderLoadedSkill } from "./skill.mjs";
+/**
+ * Package-internal resource locations.
+ *
+ * Every shipped resource is read from `dist/` and nowhere else. The bundler writes the
+ * public entries at `dist/*.mjs` and shared helper chunks under `dist/internal/`, the
+ * pstack build writes `dist/pstack/`, and the packaging step writes `dist/skills/`.
+ *
+ * `PACKAGE_ROOT` therefore sits either one level above this module (an entry bundle in
+ * `dist/`) or two (a helper chunk in `dist/internal/`). Both layouts are known, so the
+ * directory name decides instead of probing for `dist` first and falling back.
+ */
+/** Absolute path of the package root. */
+export declare const PACKAGE_ROOT: string;
+/** Absolute path of the generated pstack tree. */
+export declare const PORT_ROOT: string;
+/** Absolute path of the ported pstack skill directories. */
+export declare const SKILLS_ROOT: string;
+/** Absolute path of the vendored skill directories (`skills/vendored` at pack time). */
+export declare const VENDORED_SKILLS_ROOT: string;
+/** Absolute path of the skills authored in this repository. */
+export declare const AUTHORED_SKILLS_ROOT: string;
+/** Absolute path of the shipped harness mapping document. */
+export declare const HARNESS_DOC_PATH: string;
+/** One skill root the provider loads, labelled for collision errors. */
+interface SkillRoot {
+  readonly path: string;
+  readonly label: string;
+}
+/** Every skill root, in load order. Recursive discovery handles each root's nesting. */
+export declare const SKILL_ROOTS: readonly SkillRoot[];
+/** Standard precedence rank for packaged skill providers. */
+export declare const BUNDLED_SKILL_RANK = 600;
+/** Default provider name. */
+export declare const DEFAULT_PROVIDER_NAME = "pstack";
+/** One validated on-disk bundled skill. */
+interface BundledSkill {
+  readonly name: string;
+  readonly description: string;
+  readonly whenToUse?: string;
+  readonly invocation: SkillInvocationPolicy;
+  /** Absolute skill directory; also the resource base. */
+  readonly directory: string;
+  /** Absolute `SKILL.md` path. */
+  readonly instructionFile: string;
+}
+/** Validated skills keyed by their absolute directory. */
+type BundledSkillIndex = ReadonlyMap<string, BundledSkill>;
+/** Raised when a bundled asset violates the provider contract. */
+export declare class BundledSkillError extends Error {
+  constructor(message: string);
 }
+/**
+ * Read and validate every bundled skill under every root.
+ *
+ * A skill name may appear in only one root; a duplicate is a packaging mistake, so it
+ * fails activation rather than letting one silently shadow the other. A root that does
+ * not exist is skipped, but an empty merged catalog fails.
+ */
+export declare function loadBundledSkillIndexes(roots: readonly SkillRoot[]): BundledSkillIndex;
+/**
+ * Build the provider over an already validated index.
+ *
+ * The catalog is sorted by name so two installs present the same order, and it never
+ * changes until the package does.
+ */
+export declare function createPstackSkillProvider(index: BundledSkillIndex, providerName?: string): SkillProvider;
+/** Cordis row name, used by Loader diagnostics. */
+export declare const name = "pstack";
+/** The row needs the skill registry and the tool registry. */
 export declare const inject: string[];
-export declare function apply(ctx: Context, config?: Config): void;
-/** Absolute root of the generated skill tree, exported for doctor checks. */
-export declare const skillsRoot: string;
-export declare const skillsRootUrl: import("node:url").URL;
-//#endregion
-export type { Config };
-//# sourceMappingURL=index.d.mts.map
+/** The slice of the Cordis context this plugin requires. */
+export interface PstackSkillHost {
+  readonly skills: SkillsHost & {
+    registerProvider(create: (control: SkillProviderControl) => SkillProvider): () => void;
+  };
+  readonly tools: ToolsHost;
+  /** Optional-service read for `systemPrompt`; absent is fine. */
+  get?(name: string): unknown;
+}
+/**
+ * Register the bundled pstack skill provider and the trusted loader.
+ *
+ * @param ctx - host context carrying the skill and tool registries.
+ * @throws {import("./internal/skill-provider.ts").BundledSkillError} when the tree is malformed.
+ */
+export declare function apply(ctx: PstackSkillHost): void;
+export { type LoadSkillResult, TOOL_NAME as PSTACK_SKILL_TOOL_NAME, type SkillResourceResult, type SkillRoot, createPstackSkillTool, readSkillResource, renderLoadedSkill };