@agimon-ai/doompi-hook 0.0.1-alpha.4 → 0.0.1-alpha.41

package/dist/services/pluginHooks.d.cts

@@ -7,7 +7,6 @@ import { PluginHookDocument, ResolvedHook } from "../types/hooks.cjs";
  * maps to groups, each with an optional matcher and a list of commands. Order
  * follows the declaration order of the plugins the harness resolved.
  */
-declare function selectPluginHooks(documents: ReadonlyArray<PluginHookDocument>, eventName: string, toolName?: string): ResolvedHook[];
+export declare function selectPluginHooks(documents: ReadonlyArray<PluginHookDocument>, eventName: string, toolName?: string): ResolvedHook[];
 //#endregion
-export { selectPluginHooks };
 //# sourceMappingURL=pluginHooks.d.cts.map

package/dist/services/pluginHooks.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"pluginHooks.d.cts","names":[],"sources":["../../src/services/pluginHooks.ts"],"mappings":";;;;;;;;;iBAUgB,kBACd,WAAW,cAAc,qBACzB,mBACA,oBACC"}
+{"version":3,"file":"pluginHooks.d.cts","names":[],"sources":["../../src/services/pluginHooks.ts"],"mappings":";;;;;;;;;wBAUgB,kBACd,WAAW,cAAc,qBACzB,mBACA,oBACC"}

package/dist/services/pluginHooks.d.mts

@@ -7,7 +7,6 @@ import { PluginHookDocument, ResolvedHook } from "../types/hooks.mjs";
  * maps to groups, each with an optional matcher and a list of commands. Order
  * follows the declaration order of the plugins the harness resolved.
  */
-declare function selectPluginHooks(documents: ReadonlyArray<PluginHookDocument>, eventName: string, toolName?: string): ResolvedHook[];
+export declare function selectPluginHooks(documents: ReadonlyArray<PluginHookDocument>, eventName: string, toolName?: string): ResolvedHook[];
 //#endregion
-export { selectPluginHooks };
 //# sourceMappingURL=pluginHooks.d.mts.map

package/dist/services/pluginHooks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pluginHooks.d.mts","names":[],"sources":["../../src/services/pluginHooks.ts"],"mappings":";;;;;;;;;iBAUgB,kBACd,WAAW,cAAc,qBACzB,mBACA,oBACC"}
+{"version":3,"file":"pluginHooks.d.mts","names":[],"sources":["../../src/services/pluginHooks.ts"],"mappings":";;;;;;;;;wBAUgB,kBACd,WAAW,cAAc,qBACzB,mBACA,oBACC"}

package/dist/services/toolNames.d.cts

@@ -1,8 +1,7 @@
 //#region src/services/toolNames.d.ts
 /** The Claude name a hook matcher expects for a tool Pi just ran. */
-declare function toClaudeToolName(tool: string): string;
+export declare function toClaudeToolName(tool: string): string;
 /** Whether a matcher, if the row declares one, accepts the tool that fired. */
-declare function matchesTool(matcher: string | undefined, toolName: string | undefined): boolean;
+export declare function matchesTool(matcher: string | undefined, toolName: string | undefined): boolean;
 //#endregion
-export { matchesTool, toClaudeToolName };
 //# sourceMappingURL=toolNames.d.cts.map

package/dist/services/toolNames.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"toolNames.d.cts","names":[],"sources":["../../src/services/toolNames.ts"],"mappings":";;iBAmBgB,iBAAiB;;iBAKjB,YAAY,6BAA6B"}
+{"version":3,"file":"toolNames.d.cts","names":[],"sources":["../../src/services/toolNames.ts"],"mappings":";;wBAmBgB,iBAAiB;;wBAKjB,YAAY,6BAA6B"}

package/dist/services/toolNames.d.mts

@@ -1,8 +1,7 @@
 //#region src/services/toolNames.d.ts
 /** The Claude name a hook matcher expects for a tool Pi just ran. */
-declare function toClaudeToolName(tool: string): string;
+export declare function toClaudeToolName(tool: string): string;
 /** Whether a matcher, if the row declares one, accepts the tool that fired. */
-declare function matchesTool(matcher: string | undefined, toolName: string | undefined): boolean;
+export declare function matchesTool(matcher: string | undefined, toolName: string | undefined): boolean;
 //#endregion
-export { matchesTool, toClaudeToolName };
 //# sourceMappingURL=toolNames.d.mts.map

package/dist/services/toolNames.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"toolNames.d.mts","names":[],"sources":["../../src/services/toolNames.ts"],"mappings":";;iBAmBgB,iBAAiB;;iBAKjB,YAAY,6BAA6B"}
+{"version":3,"file":"toolNames.d.mts","names":[],"sources":["../../src/services/toolNames.ts"],"mappings":";;wBAmBgB,iBAAiB;;wBAKjB,YAAY,6BAA6B"}

package/dist/types/hooks.d.cts

@@ -7,21 +7,21 @@
  * translation onto Pi's lifecycle happens at the adapter boundary.
  */
 /** Registry event names. Each is used twice per dispatch, so drift would be silent. */
-declare const HOOK_EVENT: {
-  readonly sessionStart: "SessionStart";
-  readonly preToolUse: "PreToolUse";
-  readonly postToolUse: "PostToolUse";
-  readonly stop: "Stop";
-  readonly sessionEnd: "SessionEnd";
+export declare const HOOK_EVENT: {
+  readonly sessionStart: 'SessionStart';
+  readonly preToolUse: 'PreToolUse';
+  readonly postToolUse: 'PostToolUse';
+  readonly stop: 'Stop';
+  readonly sessionEnd: 'SessionEnd';
 };
-type HookEventName = (typeof HOOK_EVENT)[keyof typeof HOOK_EVENT];
-interface HookCommand {
+export type HookEventName = (typeof HOOK_EVENT)[keyof typeof HOOK_EVENT];
+export interface HookCommand {
   command: string;
   /** Seconds before the hook is terminated. Defaults to DEFAULT_HOOK_TIMEOUT_SECONDS. */
   timeout?: number;
 }
 /** What one registry row declares for the `pi` frontend. */
-interface RegistryBinding {
+export interface RegistryBinding {
   matcher?: string;
   command: string;
   timeout?: number;
@@ -29,7 +29,7 @@ interface RegistryBinding {
   order?: number;
 }
 /** A registry row plus the group membership used to include or drop it. */
-interface RegistryEntry extends RegistryBinding {
+export interface RegistryEntry extends RegistryBinding {
   event: string;
   order: number;
   /** Declaration order across every source, used as the sort tiebreaker. */
@@ -39,45 +39,45 @@ interface RegistryEntry extends RegistryBinding {
   /** Root of the config that declared the group, exported as CLAUDE_PLUGIN_ROOT. */
   baseDirectory: string;
 }
-interface RegistryGroup {
+export interface RegistryGroup {
   core?: boolean;
   hooks?: Array<{
     event: string;
     pi?: RegistryBinding;
   }>;
 }
-interface RegistryDocument {
+export interface RegistryDocument {
   groups?: Record<string, RegistryGroup>;
 }
 /** One `.doom/hooks.yaml` as read from disk, before it is parsed. */
-interface HookDocumentSource {
+export interface HookDocumentSource {
   baseDirectory: string;
   text: string;
 }
 /** One `.doom/hooks.yaml` after parsing, tagged with the root that declared it. */
-interface ParsedRegistrySource {
+export interface ParsedRegistrySource {
   baseDirectory: string;
   document: RegistryDocument;
 }
-interface PluginHookGroup {
+export interface PluginHookGroup {
   matcher?: string;
   hooks?: HookCommand[];
 }
-interface PluginHookConfig {
+export interface PluginHookConfig {
   hooks?: Record<string, PluginHookGroup[]>;
 }
 /** A parsed plugin config plus the root exported to its commands. */
-interface PluginHookDocument {
+export interface PluginHookDocument {
   pluginRoot: string;
   config: PluginHookConfig;
 }
 /** A hook command paired with the config root it runs against. */
-interface ResolvedHook {
+export interface ResolvedHook {
   hook: HookCommand;
   root: string;
 }
 /** The JSON a hook may write on stdout to steer or block the call it observed. */
-interface HookDecision {
+export interface HookDecision {
   decision?: string;
   reason?: string;
   hookSpecificOutput?: {
@@ -86,13 +86,13 @@ interface HookDecision {
     additionalContext?: string;
   };
 }
-type HookFailureReason = 'spawn_failed' | 'non_zero_exit' | 'timeout' | 'invalid_json' | 'registry_read' | 'plugin_config';
-interface HookFailure {
+export type HookFailureReason = 'spawn_failed' | 'non_zero_exit' | 'timeout' | 'invalid_json' | 'registry_read' | 'plugin_config';
+export interface HookFailure {
   command: string;
   message: string;
   reason: HookFailureReason;
 }
-interface HookOutcome {
+export interface HookOutcome {
   decision?: HookDecision;
   failure?: HookFailure;
 }
@@ -102,7 +102,7 @@ interface HookOutcome {
  * Pi's ToolCallEvent and ToolResultEvent both satisfy this structurally, so the
  * adapter forwards them unchanged and the payload builder stays host-neutral.
  */
-interface HookToolEvent {
+export interface HookToolEvent {
   readonly type: string;
   readonly toolName: string;
   readonly input: unknown;
@@ -110,36 +110,35 @@ interface HookToolEvent {
   readonly isError?: boolean;
 }
 /** The JSON document handed to a hook on stdin. */
-type HookPayload = Record<string, unknown>;
-interface HookRunOptions {
+export type HookPayload = Record<string, unknown>;
+export interface HookRunOptions {
   repoRoot: string;
   /** Exported as CLAUDE_PLUGIN_ROOT so a hook can reach its own scripts. */
   pluginRoot?: string;
 }
 /** Runs one hook command and reports what it decided or how it failed. */
-interface HookRunner {
+export interface HookRunner {
   run(hook: HookCommand, payload: HookPayload, options: HookRunOptions): Promise<HookOutcome>;
 }
 /** Registry rows for this repository, or the failure that emptied them. */
-interface RegistryRead {
+export interface RegistryRead {
   entries: RegistryEntry[];
   failure?: HookFailure;
 }
 /** Plugin configs that could be read, and one failure per config that could not. */
-interface PluginDocumentRead {
+export interface PluginDocumentRead {
   documents: PluginHookDocument[];
   failures: HookFailure[];
 }
 /** Where a plugin declares its hooks. Mirrors the harness state entry. */
-interface PluginHookSourceRef {
+export interface PluginHookSourceRef {
   readonly pluginRoot: string;
   readonly configPath: string;
 }
 /** Reads the hook documents a session runs from. */
-interface HookDocumentReader {
+export interface HookDocumentReader {
   registry(repoRoot: string): Promise<RegistryRead>;
   plugins(sources: readonly PluginHookSourceRef[]): Promise<PluginDocumentRead>;
 }
 //#endregion
-export { HOOK_EVENT, HookCommand, HookDecision, HookDocumentReader, HookDocumentSource, HookEventName, HookFailure, HookFailureReason, HookOutcome, HookPayload, HookRunOptions, HookRunner, HookToolEvent, ParsedRegistrySource, PluginDocumentRead, PluginHookConfig, PluginHookDocument, PluginHookGroup, PluginHookSourceRef, RegistryBinding, RegistryDocument, RegistryEntry, RegistryGroup, RegistryRead, ResolvedHook };
 //# sourceMappingURL=hooks.d.cts.map

package/dist/types/hooks.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.cts","names":[],"sources":["../../src/types/hooks.ts"],"mappings":";;;;;;;;;cASa;;;;;;;KAQD,wBAAwB,yBAAyB;UAE5C;EACf;;EAEA;;;UAIe;EACf;EACA;EACA;EACA;EACA;;;UAIe,sBAAsB;EACrC;EACA;;EAEA;EACA;EACA;;EAEA;;UAGe;EACf;EACA,QAAQ;IAAQ;IAAe,KAAK;;;UAGrB;EACf,SAAS,eAAe;;;UAIT;EACf;EACA;;;UAIe;EACf;EACA,UAAU;;UAGK;EACf;EACA,QAAQ;;UAGO;EACf,QAAQ,eAAe;;;UAIR;EACf;EACA,QAAQ;;;UAIO;EACf,MAAM;EACN;;;UAIe;EACf;EACA;EACA;IACE;IACA;IACA;;;KAIQ;UAQK;EACf;EACA;EACA,QAAQ;;UAGO;EACf,WAAW;EACX,UAAU;;;;;;;;UASK;WACN;WACA;WACA;WACA;WACA;;;KAIC,cAAc;UAET;EACf;;EAEA;;;UAIe;EACf,IAAI,MAAM,aAAa,SAAS,aAAa,SAAS,iBAAiB,QAAQ;;;UAIhE;EACf,SAAS;EACT,UAAU;;;UAIK;EACf,WAAW;EACX,UAAU;;;UAIK;WACN;WACA;;;UAIM;EACf,SAAS,mBAAmB,QAAQ;EACpC,QAAQ,kBAAkB,wBAAwB,QAAQ"}
+{"version":3,"file":"hooks.d.cts","names":[],"sources":["../../src/types/hooks.ts"],"mappings":";;;;;;;;;qBASa;WACX;WACA;WACA;WACA;WACA;;YAGU,wBAAwB,yBAAyB;iBAE5C;EACf;;EAEA;;;iBAIe;EACf;EACA;EACA;EACA;EACA;;;iBAIe,sBAAsB;EACrC;EACA;;EAEA;EACA;EACA;;EAEA;;iBAGe;EACf;EACA,QAAQ;IAAQ;IAAe,KAAK;;;iBAGrB;EACf,SAAS,eAAe;;;iBAIT;EACf;EACA;;;iBAIe;EACf;EACA,UAAU;;iBAGK;EACf;EACA,QAAQ;;iBAGO;EACf,QAAQ,eAAe;;;iBAIR;EACf;EACA,QAAQ;;;iBAIO;EACf,MAAM;EACN;;;iBAIe;EACf;EACA;EACA;IACE;IACA;IACA;;;YAIQ;iBAQK;EACf;EACA;EACA,QAAQ;;iBAGO;EACf,WAAW;EACX,UAAU;;;;;;;;iBASK;WACN;WACA;WACA;WACA;WACA;;;YAIC,cAAc;iBAET;EACf;;EAEA;;;iBAIe;EACf,IAAI,MAAM,aAAa,SAAS,aAAa,SAAS,iBAAiB,QAAQ;;;iBAIhE;EACf,SAAS;EACT,UAAU;;;iBAIK;EACf,WAAW;EACX,UAAU;;;iBAIK;WACN;WACA;;;iBAIM;EACf,SAAS,mBAAmB,QAAQ;EACpC,QAAQ,kBAAkB,wBAAwB,QAAQ"}

package/dist/types/hooks.d.mts

@@ -7,21 +7,21 @@
  * translation onto Pi's lifecycle happens at the adapter boundary.
  */
 /** Registry event names. Each is used twice per dispatch, so drift would be silent. */
-declare const HOOK_EVENT: {
-  readonly sessionStart: "SessionStart";
-  readonly preToolUse: "PreToolUse";
-  readonly postToolUse: "PostToolUse";
-  readonly stop: "Stop";
-  readonly sessionEnd: "SessionEnd";
+export declare const HOOK_EVENT: {
+  readonly sessionStart: 'SessionStart';
+  readonly preToolUse: 'PreToolUse';
+  readonly postToolUse: 'PostToolUse';
+  readonly stop: 'Stop';
+  readonly sessionEnd: 'SessionEnd';
 };
-type HookEventName = (typeof HOOK_EVENT)[keyof typeof HOOK_EVENT];
-interface HookCommand {
+export type HookEventName = (typeof HOOK_EVENT)[keyof typeof HOOK_EVENT];
+export interface HookCommand {
   command: string;
   /** Seconds before the hook is terminated. Defaults to DEFAULT_HOOK_TIMEOUT_SECONDS. */
   timeout?: number;
 }
 /** What one registry row declares for the `pi` frontend. */
-interface RegistryBinding {
+export interface RegistryBinding {
   matcher?: string;
   command: string;
   timeout?: number;
@@ -29,7 +29,7 @@ interface RegistryBinding {
   order?: number;
 }
 /** A registry row plus the group membership used to include or drop it. */
-interface RegistryEntry extends RegistryBinding {
+export interface RegistryEntry extends RegistryBinding {
   event: string;
   order: number;
   /** Declaration order across every source, used as the sort tiebreaker. */
@@ -39,45 +39,45 @@ interface RegistryEntry extends RegistryBinding {
   /** Root of the config that declared the group, exported as CLAUDE_PLUGIN_ROOT. */
   baseDirectory: string;
 }
-interface RegistryGroup {
+export interface RegistryGroup {
   core?: boolean;
   hooks?: Array<{
     event: string;
     pi?: RegistryBinding;
   }>;
 }
-interface RegistryDocument {
+export interface RegistryDocument {
   groups?: Record<string, RegistryGroup>;
 }
 /** One `.doom/hooks.yaml` as read from disk, before it is parsed. */
-interface HookDocumentSource {
+export interface HookDocumentSource {
   baseDirectory: string;
   text: string;
 }
 /** One `.doom/hooks.yaml` after parsing, tagged with the root that declared it. */
-interface ParsedRegistrySource {
+export interface ParsedRegistrySource {
   baseDirectory: string;
   document: RegistryDocument;
 }
-interface PluginHookGroup {
+export interface PluginHookGroup {
   matcher?: string;
   hooks?: HookCommand[];
 }
-interface PluginHookConfig {
+export interface PluginHookConfig {
   hooks?: Record<string, PluginHookGroup[]>;
 }
 /** A parsed plugin config plus the root exported to its commands. */
-interface PluginHookDocument {
+export interface PluginHookDocument {
   pluginRoot: string;
   config: PluginHookConfig;
 }
 /** A hook command paired with the config root it runs against. */
-interface ResolvedHook {
+export interface ResolvedHook {
   hook: HookCommand;
   root: string;
 }
 /** The JSON a hook may write on stdout to steer or block the call it observed. */
-interface HookDecision {
+export interface HookDecision {
   decision?: string;
   reason?: string;
   hookSpecificOutput?: {
@@ -86,13 +86,13 @@ interface HookDecision {
     additionalContext?: string;
   };
 }
-type HookFailureReason = 'spawn_failed' | 'non_zero_exit' | 'timeout' | 'invalid_json' | 'registry_read' | 'plugin_config';
-interface HookFailure {
+export type HookFailureReason = 'spawn_failed' | 'non_zero_exit' | 'timeout' | 'invalid_json' | 'registry_read' | 'plugin_config';
+export interface HookFailure {
   command: string;
   message: string;
   reason: HookFailureReason;
 }
-interface HookOutcome {
+export interface HookOutcome {
   decision?: HookDecision;
   failure?: HookFailure;
 }
@@ -102,7 +102,7 @@ interface HookOutcome {
  * Pi's ToolCallEvent and ToolResultEvent both satisfy this structurally, so the
  * adapter forwards them unchanged and the payload builder stays host-neutral.
  */
-interface HookToolEvent {
+export interface HookToolEvent {
   readonly type: string;
   readonly toolName: string;
   readonly input: unknown;
@@ -110,36 +110,35 @@ interface HookToolEvent {
   readonly isError?: boolean;
 }
 /** The JSON document handed to a hook on stdin. */
-type HookPayload = Record<string, unknown>;
-interface HookRunOptions {
+export type HookPayload = Record<string, unknown>;
+export interface HookRunOptions {
   repoRoot: string;
   /** Exported as CLAUDE_PLUGIN_ROOT so a hook can reach its own scripts. */
   pluginRoot?: string;
 }
 /** Runs one hook command and reports what it decided or how it failed. */
-interface HookRunner {
+export interface HookRunner {
   run(hook: HookCommand, payload: HookPayload, options: HookRunOptions): Promise<HookOutcome>;
 }
 /** Registry rows for this repository, or the failure that emptied them. */
-interface RegistryRead {
+export interface RegistryRead {
   entries: RegistryEntry[];
   failure?: HookFailure;
 }
 /** Plugin configs that could be read, and one failure per config that could not. */
-interface PluginDocumentRead {
+export interface PluginDocumentRead {
   documents: PluginHookDocument[];
   failures: HookFailure[];
 }
 /** Where a plugin declares its hooks. Mirrors the harness state entry. */
-interface PluginHookSourceRef {
+export interface PluginHookSourceRef {
   readonly pluginRoot: string;
   readonly configPath: string;
 }
 /** Reads the hook documents a session runs from. */
-interface HookDocumentReader {
+export interface HookDocumentReader {
   registry(repoRoot: string): Promise<RegistryRead>;
   plugins(sources: readonly PluginHookSourceRef[]): Promise<PluginDocumentRead>;
 }
 //#endregion
-export { HOOK_EVENT, HookCommand, HookDecision, HookDocumentReader, HookDocumentSource, HookEventName, HookFailure, HookFailureReason, HookOutcome, HookPayload, HookRunOptions, HookRunner, HookToolEvent, ParsedRegistrySource, PluginDocumentRead, PluginHookConfig, PluginHookDocument, PluginHookGroup, PluginHookSourceRef, RegistryBinding, RegistryDocument, RegistryEntry, RegistryGroup, RegistryRead, ResolvedHook };
 //# sourceMappingURL=hooks.d.mts.map

package/dist/types/hooks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.mts","names":[],"sources":["../../src/types/hooks.ts"],"mappings":";;;;;;;;;cASa;;;;;;;KAQD,wBAAwB,yBAAyB;UAE5C;EACf;;EAEA;;;UAIe;EACf;EACA;EACA;EACA;EACA;;;UAIe,sBAAsB;EACrC;EACA;;EAEA;EACA;EACA;;EAEA;;UAGe;EACf;EACA,QAAQ;IAAQ;IAAe,KAAK;;;UAGrB;EACf,SAAS,eAAe;;;UAIT;EACf;EACA;;;UAIe;EACf;EACA,UAAU;;UAGK;EACf;EACA,QAAQ;;UAGO;EACf,QAAQ,eAAe;;;UAIR;EACf;EACA,QAAQ;;;UAIO;EACf,MAAM;EACN;;;UAIe;EACf;EACA;EACA;IACE;IACA;IACA;;;KAIQ;UAQK;EACf;EACA;EACA,QAAQ;;UAGO;EACf,WAAW;EACX,UAAU;;;;;;;;UASK;WACN;WACA;WACA;WACA;WACA;;;KAIC,cAAc;UAET;EACf;;EAEA;;;UAIe;EACf,IAAI,MAAM,aAAa,SAAS,aAAa,SAAS,iBAAiB,QAAQ;;;UAIhE;EACf,SAAS;EACT,UAAU;;;UAIK;EACf,WAAW;EACX,UAAU;;;UAIK;WACN;WACA;;;UAIM;EACf,SAAS,mBAAmB,QAAQ;EACpC,QAAQ,kBAAkB,wBAAwB,QAAQ"}
+{"version":3,"file":"hooks.d.mts","names":[],"sources":["../../src/types/hooks.ts"],"mappings":";;;;;;;;;qBASa;WACX;WACA;WACA;WACA;WACA;;YAGU,wBAAwB,yBAAyB;iBAE5C;EACf;;EAEA;;;iBAIe;EACf;EACA;EACA;EACA;EACA;;;iBAIe,sBAAsB;EACrC;EACA;;EAEA;EACA;EACA;;EAEA;;iBAGe;EACf;EACA,QAAQ;IAAQ;IAAe,KAAK;;;iBAGrB;EACf,SAAS,eAAe;;;iBAIT;EACf;EACA;;;iBAIe;EACf;EACA,UAAU;;iBAGK;EACf;EACA,QAAQ;;iBAGO;EACf,QAAQ,eAAe;;;iBAIR;EACf;EACA,QAAQ;;;iBAIO;EACf,MAAM;EACN;;;iBAIe;EACf;EACA;EACA;IACE;IACA;IACA;;;YAIQ;iBAQK;EACf;EACA;EACA,QAAQ;;iBAGO;EACf,WAAW;EACX,UAAU;;;;;;;;iBASK;WACN;WACA;WACA;WACA;WACA;;;YAIC,cAAc;iBAET;EACf;;EAEA;;;iBAIe;EACf,IAAI,MAAM,aAAa,SAAS,aAAa,SAAS,iBAAiB,QAAQ;;;iBAIhE;EACf,SAAS;EACT,UAAU;;;iBAIK;EACf,WAAW;EACX,UAAU;;;iBAIK;WACN;WACA;;;iBAIM;EACf,SAAS,mBAAmB,QAAQ;EACpC,QAAQ,kBAAkB,wBAAwB,QAAQ"}

package/dist/types/telemetry.d.cts

@@ -1,20 +1,19 @@
 //#region src/types/telemetry.d.ts
 /** Telemetry events this package reports, and the port that records them. */
-declare const HOOK_TELEMETRY_EVENT: {
-  readonly hookFailed: "doom_pi_hook.failed";
-  readonly hookRegistryReadFailed: "doom_pi_hook.registry_read_failed";
+export declare const HOOK_TELEMETRY_EVENT: {
+  readonly hookFailed: 'doom_pi_hook.failed';
+  readonly hookRegistryReadFailed: 'doom_pi_hook.registry_read_failed';
 };
-type HookTelemetryEventName = (typeof HOOK_TELEMETRY_EVENT)[keyof typeof HOOK_TELEMETRY_EVENT];
-type HookTelemetryAttributes = Record<string, string | number | boolean>;
+export type HookTelemetryEventName = (typeof HOOK_TELEMETRY_EVENT)[keyof typeof HOOK_TELEMETRY_EVENT];
+export type HookTelemetryAttributes = Record<string, string | number | boolean>;
 /**
  * A hook that never ran is indistinguishable from one that passed, which is why
  * both a failed run and an unreadable registry are worth reporting rather than
  * swallowing.
  */
-interface HookTelemetry {
+export interface HookTelemetry {
   recordError(event: HookTelemetryEventName, error: unknown, attributes?: HookTelemetryAttributes): Promise<void>;
   recordWarning(event: HookTelemetryEventName, error: unknown, attributes?: HookTelemetryAttributes): Promise<void>;
 }
 //#endregion
-export { HOOK_TELEMETRY_EVENT, HookTelemetry, HookTelemetryAttributes, HookTelemetryEventName };
 //# sourceMappingURL=telemetry.d.cts.map

package/dist/types/telemetry.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"telemetry.d.cts","names":[],"sources":["../../src/types/telemetry.ts"],"mappings":";;cACa;WAAA;WAAA;;KAKD,iCAAiC,mCAAmC;KACpE,0BAA0B;;;;;;UAOrB;EACf,YAAY,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B;EAClG,cAAc,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B"}
+{"version":3,"file":"telemetry.d.cts","names":[],"sources":["../../src/types/telemetry.ts"],"mappings":";;qBACa;WACX;WACA;;YAGU,iCAAiC,mCAAmC;YACpE,0BAA0B;;;;;;iBAOrB;EACf,YAAY,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B;EAClG,cAAc,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B"}

package/dist/types/telemetry.d.mts

@@ -1,20 +1,19 @@
 //#region src/types/telemetry.d.ts
 /** Telemetry events this package reports, and the port that records them. */
-declare const HOOK_TELEMETRY_EVENT: {
-  readonly hookFailed: "doom_pi_hook.failed";
-  readonly hookRegistryReadFailed: "doom_pi_hook.registry_read_failed";
+export declare const HOOK_TELEMETRY_EVENT: {
+  readonly hookFailed: 'doom_pi_hook.failed';
+  readonly hookRegistryReadFailed: 'doom_pi_hook.registry_read_failed';
 };
-type HookTelemetryEventName = (typeof HOOK_TELEMETRY_EVENT)[keyof typeof HOOK_TELEMETRY_EVENT];
-type HookTelemetryAttributes = Record<string, string | number | boolean>;
+export type HookTelemetryEventName = (typeof HOOK_TELEMETRY_EVENT)[keyof typeof HOOK_TELEMETRY_EVENT];
+export type HookTelemetryAttributes = Record<string, string | number | boolean>;
 /**
  * A hook that never ran is indistinguishable from one that passed, which is why
  * both a failed run and an unreadable registry are worth reporting rather than
  * swallowing.
  */
-interface HookTelemetry {
+export interface HookTelemetry {
   recordError(event: HookTelemetryEventName, error: unknown, attributes?: HookTelemetryAttributes): Promise<void>;
   recordWarning(event: HookTelemetryEventName, error: unknown, attributes?: HookTelemetryAttributes): Promise<void>;
 }
 //#endregion
-export { HOOK_TELEMETRY_EVENT, HookTelemetry, HookTelemetryAttributes, HookTelemetryEventName };
 //# sourceMappingURL=telemetry.d.mts.map

package/dist/types/telemetry.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"telemetry.d.mts","names":[],"sources":["../../src/types/telemetry.ts"],"mappings":";;cACa;WAAA;WAAA;;KAKD,iCAAiC,mCAAmC;KACpE,0BAA0B;;;;;;UAOrB;EACf,YAAY,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B;EAClG,cAAc,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B"}
+{"version":3,"file":"telemetry.d.mts","names":[],"sources":["../../src/types/telemetry.ts"],"mappings":";;qBACa;WACX;WACA;;YAGU,iCAAiC,mCAAmC;YACpE,0BAA0B;;;;;;iBAOrB;EACf,YAAY,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B;EAClG,cAAc,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B"}

package/llms.txt

@@ -2,6 +2,10 @@
 
 Claude-Code-compatible repository and plugin hooks for Doom Pi sessions.
 
-## Resources
+## How to author
 
-- [Package README](./README.md): the `.doom/hooks.yaml` document, group selection, the event mapping, and what a hook decision can do.
+- [Author DoomPi hooks](./src/prompts/doompi-author-hook/SKILL.md): Create `.doom/hooks.yaml` groups and Claude-compatible hook commands.
+
+## Package reference
+
+- [Package README](./README.md): The hook registry, group selection, event mapping, decisions, and failure handling.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agimon-ai/doompi-hook",
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.41",
   "description": "Claude-Code-compatible repository and plugin hook runner for DoomPi sessions.",
   "keywords": [
     "ai",
@@ -16,12 +16,21 @@
     "repository-hooks"
   ],
   "homepage": "https://agimon.ai",
+  "bugs": {
+    "url": "https://github.com/AgiFlow/doompi/issues"
+  },
   "license": "MIT",
   "author": "Vuong Ngo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AgiFlow/doompi.git",
+    "directory": "packages/default/doompi-hook"
+  },
   "files": [
     "dist",
     "llms.txt",
     "README.md",
+    "src/prompts",
     "LICENSE",
     "package.json"
   ],
@@ -46,23 +55,23 @@
     "access": "public"
   },
   "dependencies": {
-    "@deepseek-ai/cordis": "4.0.1",
+    "@deepseek-ai/cordis": "4.0.2",
     "yaml": "2.9.0",
-    "@agimon-ai/doompi-config": "0.0.1-alpha.26",
-    "@agimon-ai/doompi-extension-contracts": "0.0.1-alpha.26",
-    "@agimon-ai/doompi-telemetry": "0.0.1-alpha.26"
+    "@agimon-ai/doompi-config": "0.0.1-alpha.63",
+    "@agimon-ai/doompi-telemetry": "0.0.1-alpha.62",
+    "@agimon-ai/doompi-extension-contracts": "0.0.1-alpha.63"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.2",
-    "@types/node": "26.1.1",
-    "@vitest/coverage-v8": "4.1.10",
-    "tsdown": "0.22.14",
-    "typescript": "6.0.3",
-    "vitest": "4.1.10",
-    "@agimon-ai/vibe-lint-plugin-doom-extension": "0.0.1-alpha.26"
+    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@types/node": "26.4.1",
+    "@vitest/coverage-v8": "5.0.0",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.0",
+    "@agimon-ai/vibe-lint-plugin-doom-extension": "0.0.1-alpha.60"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.2"
+    "@earendil-works/pi-coding-agent": "0.85.1"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {

package/src/prompts/doompi-author-hook/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: doompi-author-hook
+description: Author DoomPi repository or plugin hooks. Use when creating or changing .doom/hooks.yaml, selecting hook groups from modes.yaml, writing hook commands, or adapting Claude Code hook payloads and decisions to DoomPi.
+---
+
+# Author DoomPi hooks
+
+Write the smallest hook that enforces the requested policy, and treat every hook command as executable repository code.
+
+## Repository registry
+
+Define repository and personal hooks in `.doom/hooks.yaml`:
+
+```yaml
+groups:
+  safety:
+    core: true
+    hooks:
+      - event: PreToolUse
+        pi:
+          matcher: Bash
+          command: .doom/hooks/guard-destructive-commands.sh
+          timeout: 10
+          skipInSubagent: true
+          order: 0
+```
+
+- Personal configuration comes from `~/.pi/.doom/hooks.yaml`; repository configuration comes from `<repo>/.doom/hooks.yaml`.
+- A repository group replaces a personal group with the same ID as one complete value.
+- `core: true` runs regardless of the selected groups. Otherwise, add the group ID to a layer's `hookGroups` in `modes.yaml`.
+- `matcher` is a regular expression over Claude tool names such as `Bash` and `Write`, even though Pi uses lowercase tool names internally.
+- Use `skipInSubagent: true` when running the hook in a child could duplicate or close parent-owned work. Lower `order` values run first, with declaration order as the tiebreaker.
+
+Supported repository events are `SessionStart`, `PreToolUse`, `PostToolUse`, and `Stop`. `SessionEnd` is resolved only from plugin `hooks.json` documents.
+
+## Command contract
+
+DoomPi runs each command through `/bin/bash -c` from the repository root and writes the Claude-compatible event payload to stdin. The environment includes `CLAUDE_PROJECT_DIR`, `CODEX_REPO_ROOT`, `ORIGINAL_REPO_PATH`, and `CLAUDE_PLUGIN_ROOT`. For `.doom/hooks.yaml`, `CLAUDE_PLUGIN_ROOT` is the root that declared the personal or repository document.
+
+The final stdout line beginning with `{` is parsed as the hook decision. Use Claude Code decision fields only when the event supports them. `PreToolUse` may deny a tool or add context, `PostToolUse` may append context or mark a result as denied, and `SessionStart` may add context. `Stop` and `SessionEnd` run for side effects.
+
+Hook failures are advisory: nonzero exits, invalid JSON, spawn failures, and timeouts are reported to the agent instead of crashing the turn. Set `timeout` in seconds only when the 10-second default is unsuitable. A timeout terminates the command's process group.
+
+## Verification
+
+Before enabling a new hook broadly:
+
+1. Run the command directly with a representative JSON payload on stdin.
+2. Start DoomPi with the intended major mode and confirm the group appears in `doompi --explain` output.
+3. Exercise the exact lifecycle event in a disposable session, including a child session when `skipInSubagent` matters.
+4. Confirm failure output reaches the agent and that repeated shutdown does not repeat external side effects unexpectedly.