@fro.bot/systematic 2.12.0 → 2.12.1

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
   findCommandsInDir,
   findSkillsInDir,
   getConfigPaths
-} from "./index-g602hys2.js";
+} from "./index-b4ht76qd.js";
 
 // src/cli.ts
 import fs from "fs";

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 import type { Plugin } from '@opencode-ai/plugin';
+export declare const applyBootstrapContent: (output: {
+    system: string[];
+}, content: string) => void;
 declare const SystematicPlugin: Plugin;
 export default SystematicPlugin;

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   loadConfig,
   loadConfigWithSources,
   parseFrontmatter
-} from "./index-g602hys2.js";
+} from "./index-b4ht76qd.js";
 
 // src/index.ts
 import fs4 from "fs";
@@ -686,29 +686,6 @@ function registerSkillsPaths(config, skillsDir) {
   };
 }
 
-// src/lib/plugin-singleton.ts
-var SINGLETON_KEY = Symbol.for("systematic.singleton.v1");
-async function plugInOnce({
-  doInit,
-  pid
-}) {
-  const currentPid = pid ?? process.pid;
-  const g = globalThis;
-  const existing = g[SINGLETON_KEY];
-  if (existing && existing.pid === currentPid) {
-    const hooks2 = await existing.hooksPromise;
-    return { isFirst: false, hooks: hooks2 };
-  }
-  const hooksPromise = doInit();
-  g[SINGLETON_KEY] = {
-    pid: currentPid,
-    loadedAt: Date.now(),
-    hooksPromise
-  };
-  const hooks = await hooksPromise;
-  return { isFirst: true, hooks };
-}
-
 // src/lib/skill-tool.ts
 import fs3 from "fs";
 import path4 from "path";
@@ -871,8 +848,26 @@ var bundledSkillsDir = path5.join(packageRoot, "skills");
 var bundledAgentsDir = path5.join(packageRoot, "agents");
 var bundledCommandsDir = path5.join(packageRoot, "commands");
 var packageJsonPath = path5.join(packageRoot, "package.json");
-var hasLoggedInit = false;
+var BOOTSTRAP_MARKER_OPEN = "<SYSTEMATIC_WORKFLOWS>";
+var BOOTSTRAP_MARKER_CLOSE = "</SYSTEMATIC_WORKFLOWS>";
+var findBootstrapMarkerBlock = (entry) => {
+  const start = entry.indexOf(BOOTSTRAP_MARKER_OPEN);
+  if (start === -1)
+    return null;
+  const closeStart = entry.indexOf(BOOTSTRAP_MARKER_CLOSE, start + BOOTSTRAP_MARKER_OPEN.length);
+  if (closeStart === -1)
+    return null;
+  return { start, end: closeStart + BOOTSTRAP_MARKER_CLOSE.length };
+};
 var applyBootstrapContent = (output, content) => {
+  for (let i = 0;i < output.system.length; i++) {
+    const entry = output.system[i];
+    const block = findBootstrapMarkerBlock(entry);
+    if (block !== null) {
+      output.system[i] = entry.slice(0, block.start) + content + entry.slice(block.end);
+      return;
+    }
+  }
   if (output.system.length > 0) {
     output.system[output.system.length - 1] += `
 
@@ -893,6 +888,7 @@ var getPackageVersion = () => {
   }
 };
 var initializePlugin = async ({ client, directory }) => {
+  let hasLoggedInit = false;
   const config = loadConfig(directory);
   const bootstrapContent = getBootstrapContent(config, { bundledSkillsDir });
   const configHandler = createConfigHandler({
@@ -951,12 +947,10 @@ var initializePlugin = async ({ client, directory }) => {
   };
 };
 var SystematicPlugin = async (input) => {
-  const { hooks } = await plugInOnce({
-    doInit: () => initializePlugin(input)
-  });
-  return hooks;
+  return initializePlugin(input);
 };
 var src_default = SystematicPlugin;
 export {
-  src_default as default
+  src_default as default,
+  applyBootstrapContent
 };

package/dist/lib/config-schema.d.ts

@@ -158,11 +158,13 @@ export declare const SystematicConfigSchema: z.ZodObject<{
         file: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export interface ValidationResult {
-    success: boolean;
-    data?: z.infer<typeof SystematicConfigSchema>;
-    errors?: readonly z.ZodIssue[];
-}
+export type ValidationResult = {
+    success: true;
+    data: z.infer<typeof SystematicConfigSchema>;
+} | {
+    success: false;
+    errors: readonly z.ZodIssue[];
+};
 export declare function validateConfig(input: unknown): ValidationResult;
 export declare function assertSourceCategoryModelDefaults(defaults: Record<string, unknown>): void;
 /**

package/dist/lib/config.d.ts

@@ -1,4 +1,3 @@
-import type { z } from 'zod';
 export interface BootstrapConfig {
     enabled: boolean;
     file?: string;
@@ -27,26 +26,6 @@ export interface SystematicConfig {
     categories?: OverlayConfigMap;
 }
 export declare const DEFAULT_CONFIG: SystematicConfig;
-interface RawSystematicConfig extends Omit<Partial<SystematicConfig>, 'agents' | 'categories'> {
-    agents?: unknown;
-    categories?: unknown;
-}
-interface ConfigSource {
-    path: string;
-    config: RawSystematicConfig;
-    trust: 'user' | 'project' | 'custom';
-}
-/**
- * Type guard for errors thrown by the top-level config schema validator.
- * Use this to distinguish schema validation failures from JSONC parse errors
- * or file read errors.
- */
-export declare function isConfigSchemaError(err: unknown): err is Error & {
-    _tag: 'ConfigSchemaError';
-    filePath: string;
-    trust: ConfigSource['trust'];
-    issues: readonly z.core.$ZodIssue[];
-};
 export declare function loadConfig(projectDir: string): SystematicConfig;
 export declare function loadConfigWithSources(projectDir: string): SourceAwareConfigResult;
 export declare function getConfigPaths(projectDir: string): {
@@ -57,4 +36,3 @@ export declare function getConfigPaths(projectDir: string): {
     userDir: string;
     projectDir: string;
 };
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "2.12.0",
+  "version": "2.12.1",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "homepage": "https://fro.bot/systematic",

package/dist/lib/plugin-singleton.d.ts

@@ -1,60 +0,0 @@
-/**
- * Per-process register-once guard for the Systematic plugin factory.
- *
- * OpenCode invokes the plugin factory more than once per process when the
- * same plugin is referenced by multiple config sources (for example a
- * user-level `~/.config/opencode/opencode.json` AND a project-level
- * `opencode.json`). Each invocation evaluates the plugin module fresh —
- * module-local variables reset between calls — so the guard state must
- * live on `globalThis` to persist across module instances within the
- * same process.
- *
- * On the first invocation `doInit` runs and the resulting hooks promise
- * is cached on `globalThis`; the caller receives `{ isFirst: true, hooks }`.
- * On every subsequent invocation in the same PID `doInit` is skipped and
- * the cached resolved hooks are returned directly to every caller.
- * Across PIDs the guard is treated as absent and init runs fresh —
- * `globalThis` is per-process, but the explicit PID check adds defensive
- * belt-and-suspenders against any state-leakage edge case.
- *
- * The singleton returns the same hooks reference to every caller within a
- * process — first and duplicate alike. OpenCode may register the same hook
- * surface once per configured plugin source; that is preferable to suppressing
- * duplicates with an empty object because every source keeps the full tools,
- * commands, skills, and hooks surface.
- *
- * **Known limitation — rejected init is sticky.** If `doInit()` rejects,
- * the rejected promise is stored on `globalThis` and every subsequent
- * invocation in the same PID returns the same rejection without retrying
- * init. This is intentional: re-running heavy init on every call would
- * defeat the guard's purpose. Recovery requires a process restart.
- */
-export interface PlugInOnceOptions<T> {
-    /** Heavy init work that should run at most once per process. */
-    doInit: () => Promise<T>;
-    /** Test override; defaults to `process.pid`. */
-    pid?: number;
-}
-/**
- * Result envelope for `plugInOnce(...)`.
- *
- * - `isFirst: true` — caller was the first invocation in this process.
- * - `isFirst: false` — `doInit` was skipped; the cached result is returned.
- *
- * In both cases `hooks` is the real resolved value of `doInit()`. Callers
- * return `result.hooks` unconditionally without inspecting `isFirst`.
- */
-export interface PlugInOnceResult<T> {
-    isFirst: boolean;
-    hooks: T;
-}
-/**
- * Run `doInit` at most once per process; on duplicate invocations return the
- * cached real hook surface so every config source sees the same surface.
- */
-export declare function plugInOnce<T>({ doInit, pid, }: PlugInOnceOptions<T>): Promise<PlugInOnceResult<T>>;
-/**
- * Test-only: clear the singleton state so the next invocation re-runs
- * init. Must not be called in production code paths.
- */
-export declare function _resetPluginSingleton(): void;