@digi4care/omo-slim-decision-layer 0.2.3 → 0.4.0

package/README.md

@@ -27,6 +27,16 @@ Built as a companion plugin for
 - **Traceability** — typed links (`refines`, `depends_on`, `constrains`,
   `relates_to`) between records, with queries for orphans and reverse lookup.
 
+## Compatibility
+
+One package, two registration paths, sharing the same register and tool logic:
+
+- **v1** (`@opencode-ai/plugin` 1.x): the default export provides a v1 `server`
+  that registers the nine tools and the `command.execute.before` hook.
+- **v2** (`@opencode/plugin` 2.x): the same default export also provides a v2
+  `setup` that registers the tools via `ctx.tool.transform` and injects the
+  prompt via `ctx.session.hook('prompt')`.
+
 ## Agent tools
 
 | Tool | Purpose |

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { Plugin } from '@opencode-ai/plugin';
-declare const _default: {
+declare const pluginModule: {
     id: string;
     server: Plugin;
+    setup: (ctx: import("./v2/setup").V2Context) => Promise<void>;
 };
-export default _default;
+export default pluginModule;

package/dist/index.js

@@ -3569,7 +3569,16 @@ import { z as z4 } from "zod";
 import { z } from "zod";
 var RecordTypes = ["REQ", "CONSTRAINT", "ASSUMPTION", "DEC"];
 var RecordStatuses = ["proposed", "accepted", "rejected", "superseded"];
-var LinkRelations = ["refines", "depends_on", "constrains", "relates_to"];
+var LinkRelations = [
+  "refines",
+  "depends_on",
+  "constrains",
+  "relates_to",
+  "decides",
+  "implements",
+  "satisfies",
+  "external"
+];
 var TypeOrder = {
   REQ: 0,
   CONSTRAINT: 1,
@@ -3597,8 +3606,19 @@ var RecordId = z.string().superRefine((val, ctx) => {
 });
 var LinkSchema = z.object({
   type: z.enum(LinkRelations),
-  target: RecordId,
+  target: z.string().min(1, "Link target is required"),
   rationale: z.string().min(1, "Link rationale is required")
+}).superRefine((link, ctx) => {
+  if (link.type === "external")
+    return;
+  const parsed = RecordId.safeParse(link.target);
+  if (!parsed.success) {
+    ctx.addIssue({
+      code: "custom",
+      message: parsed.error.issues.map((issue) => issue.message).join("; "),
+      path: ["target"]
+    });
+  }
 });
 var BaseRecordFields = {
   schema_version: z.literal("1.0"),
@@ -3608,7 +3628,9 @@ var BaseRecordFields = {
   change_authority: z.string().min(1, "Change authority is required"),
   supersedes: z.array(RecordId).default([]),
   status_reason: z.string().optional(),
-  links: z.array(LinkSchema).default([])
+  links: z.array(LinkSchema).default([]),
+  context: z.string().optional(),
+  meta: z.record(z.string(), z.unknown()).optional()
 };
 function createRecordSchema(type) {
   return z.object({
@@ -3622,13 +3644,13 @@ function createRecordSchema(type) {
         });
       }
     })
-  });
+  }).strict();
 }
 var ReqRecordSchema = createRecordSchema("REQ");
 var ConstraintRecordSchema = createRecordSchema("CONSTRAINT");
 var AssumptionRecordSchema = createRecordSchema("ASSUMPTION").extend({
   needed_to_close: z.string().min(1, "needed_to_close is required")
-});
+}).strict();
 var DecRecordSchema = createRecordSchema("DEC").extend({
   decision: z.string().min(1, "Decision is required"),
   alternatives_rejected: z.array(z.object({
@@ -3636,7 +3658,7 @@ var DecRecordSchema = createRecordSchema("DEC").extend({
     rejected_because: z.string().min(1, "Rejection reason is required")
   })).default([]),
   consequences: z.string().min(1, "Consequences are required")
-});
+}).strict();
 var RecordSchema = z.discriminatedUnion("type", [
   ReqRecordSchema,
   ConstraintRecordSchema,
@@ -3648,16 +3670,18 @@ var BaseAddInputFields = {
   owner: z.string().optional(),
   change_authority: z.string().optional(),
   supersedes: z.array(RecordId).optional(),
-  links: z.array(LinkSchema).optional()
+  links: z.array(LinkSchema).optional(),
+  context: z.string().optional(),
+  meta: z.record(z.string(), z.unknown()).optional()
 };
 var AddRecordInputSchema = z.discriminatedUnion("type", [
-  z.object({ ...BaseAddInputFields, type: z.literal("REQ") }),
-  z.object({ ...BaseAddInputFields, type: z.literal("CONSTRAINT") }),
+  z.object({ ...BaseAddInputFields, type: z.literal("REQ") }).strict(),
+  z.object({ ...BaseAddInputFields, type: z.literal("CONSTRAINT") }).strict(),
   z.object({
     ...BaseAddInputFields,
     type: z.literal("ASSUMPTION"),
     needed_to_close: z.string().min(1, "needed_to_close is required")
-  }),
+  }).strict(),
   z.object({
     ...BaseAddInputFields,
     type: z.literal("DEC"),
@@ -3667,7 +3691,7 @@ var AddRecordInputSchema = z.discriminatedUnion("type", [
       rejected_because: z.string().min(1, "Rejection reason is required")
     })).optional(),
     consequences: z.string().min(1, "Consequences are required")
-  })
+  }).strict()
 ]);
 function sortRecords(records) {
   return [...records].sort((a, b) => {
@@ -3723,7 +3747,9 @@ var RecordKeyOrder = {
   needed_to_close: 10,
   decision: 11,
   alternatives_rejected: 12,
-  consequences: 13
+  consequences: 13,
+  context: 14,
+  meta: 15
 };
 var LinkKeyOrder = {
   type: 0,
@@ -3745,6 +3771,8 @@ function validateLinkIntegrity(register) {
   const ids = new Set(register.records.map((r) => r.id));
   for (const record of register.records) {
     for (const link of record.links) {
+      if (link.type === "external")
+        continue;
       if (!ids.has(link.target)) {
         return `Record ${record.id} links to non-existent target ${link.target}`;
       }
@@ -3775,6 +3803,12 @@ function normalizeRecord(record) {
   if (base.status_reason === undefined) {
     delete base.status_reason;
   }
+  if (base.context === undefined) {
+    delete base.context;
+  }
+  if (base.meta === undefined) {
+    delete base.meta;
+  }
   if (Array.isArray(base.links)) {
     base.links = base.links.map((link) => sortObjectKeys(link, LinkKeyOrder));
   }
@@ -3858,6 +3892,14 @@ function initRegister(filePath, workspace) {
   };
   writeRegister(filePath, register);
 }
+function withExtras(base, input) {
+  const extras = base;
+  if (input.context !== undefined)
+    extras.context = input.context;
+  if (input.meta !== undefined)
+    extras.meta = input.meta;
+  return base;
+}
 function addRecord(filePath, input) {
   if (!fs.existsSync(filePath)) {
     throw new Error(`Register not found at ${filePath}. Run the decision-init tool first to create a new register.`);
@@ -3866,7 +3908,7 @@ function addRecord(filePath, input) {
   const id = allocateId(register.records, input.type);
   const owner = input.owner ?? register.workspace.owner;
   const change_authority = input.change_authority ?? register.workspace.change_authority;
-  const base = {
+  const base = withExtras({
     schema_version: "1.0",
     id,
     type: input.type,
@@ -3876,7 +3918,7 @@ function addRecord(filePath, input) {
     change_authority,
     supersedes: input.supersedes ?? [],
     links: input.links ?? []
-  };
+  }, input);
   let record;
   switch (input.type) {
     case "REQ":
@@ -3938,7 +3980,7 @@ function supersedeRecord(filePath, oldId, newRecordInput, reason) {
   const newId = allocateId(register.records, newRecordInput.type);
   const owner = newRecordInput.owner ?? register.workspace.owner;
   const change_authority = newRecordInput.change_authority ?? register.workspace.change_authority;
-  const base = {
+  const base = withExtras({
     schema_version: "1.0",
     id: newId,
     type: newRecordInput.type,
@@ -3948,7 +3990,7 @@ function supersedeRecord(filePath, oldId, newRecordInput, reason) {
     change_authority,
     supersedes: [oldId],
     links: newRecordInput.links ?? []
-  };
+  }, newRecordInput);
   let newRecord;
   switch (newRecordInput.type) {
     case "REQ":
@@ -4113,6 +4155,9 @@ function generateMarkdownView(register) {
     if (record.status_reason !== undefined) {
       lines.push(`- Status reason: ${record.status_reason}`);
     }
+    if (record.context !== undefined) {
+      lines.push(`- Context: ${record.context}`);
+    }
     if (record.links.length > 0) {
       lines.push("- Links:");
       for (const link of record.links) {
@@ -4307,6 +4352,55 @@ function createDecisionTools() {
   };
 }
 
+// src/v2/setup.ts
+import { z as z5 } from "zod";
+var INTERVIEW_MARKER = "You are running an interview q&a session for the user inside their repository";
+var SENTINEL2 = "<!-- decision-layer:inject v1 -->";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createV2Setup() {
+  return async (ctx) => {
+    const projectDir = ctx.location.directory;
+    const tools = createDecisionTools();
+    await ctx.tool.transform((editor) => {
+      for (const [name, definition] of Object.entries(tools)) {
+        editor.add({
+          name,
+          description: definition.description,
+          input: z5.object(definition.args),
+          execute: async (input, toolContext) => {
+            const v1Context = {
+              ...isRecord(toolContext) ? toolContext : {},
+              worktree: projectDir,
+              directory: projectDir
+            };
+            const result = await definition.execute(input, v1Context);
+            return { content: result };
+          }
+        });
+      }
+    });
+    await ctx.session.hook("prompt", async (event) => {
+      try {
+        if (!isRecord(event))
+          return;
+        const prompt = event.prompt;
+        if (!isRecord(prompt) || typeof prompt.text !== "string")
+          return;
+        if (!prompt.text.includes(INTERVIEW_MARKER))
+          return;
+        if (prompt.text.includes(SENTINEL2))
+          return;
+        prompt.text = `${prompt.text}
+
+${SENTINEL2}
+${DECISION_DISCIPLINE_PROMPT}`;
+      } catch {}
+    });
+  };
+}
+
 // src/index.ts
 var DecisionLayer = async () => {
   const hooks = {
@@ -4315,10 +4409,12 @@ var DecisionLayer = async () => {
   };
   return hooks;
 };
-var src_default = {
+var pluginModule = {
   id: "omo-slim-decision-layer",
-  server: DecisionLayer
+  server: DecisionLayer,
+  setup: createV2Setup()
 };
+var src_default = pluginModule;
 export {
   src_default as default
 };

package/dist/model/record.d.ts

@@ -3,7 +3,7 @@ export declare const RecordTypes: readonly ['REQ', 'CONSTRAINT', 'ASSUMPTION', '
 export type RecordType = (typeof RecordTypes)[number];
 export declare const RecordStatuses: readonly ['proposed', 'accepted', 'rejected', 'superseded'];
 export type RecordStatus = (typeof RecordStatuses)[number];
-export declare const LinkRelations: readonly ['refines', 'depends_on', 'constrains', 'relates_to'];
+export declare const LinkRelations: readonly ['refines', 'depends_on', 'constrains', 'relates_to', 'decides', 'implements', 'satisfies', 'external'];
 export type LinkRelation = (typeof LinkRelations)[number];
 export declare function recordIdPattern(type: RecordType): RegExp;
 export declare const RecordId: z.ZodString;
@@ -11,9 +11,13 @@ export type RecordId = z.infer<typeof RecordId>;
 export declare const LinkSchema: z.ZodObject<{
     type: z.ZodEnum<{
         constrains: "constrains";
+        decides: "decides";
         depends_on: "depends_on";
+        external: "external";
+        implements: "implements";
         refines: "refines";
         relates_to: "relates_to";
+        satisfies: "satisfies";
     }>;
     target: z.ZodString;
     rationale: z.ZodString;
@@ -35,16 +39,22 @@ export declare const ReqRecordSchema: z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"REQ">;
     id: z.ZodString;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const ConstraintRecordSchema: z.ZodObject<{
     schema_version: z.ZodLiteral<"1.0">;
     title: z.ZodString;
@@ -61,16 +71,22 @@ export declare const ConstraintRecordSchema: z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"CONSTRAINT">;
     id: z.ZodString;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const AssumptionRecordSchema: z.ZodObject<{
     schema_version: z.ZodLiteral<"1.0">;
     title: z.ZodString;
@@ -87,17 +103,23 @@ export declare const AssumptionRecordSchema: z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"ASSUMPTION">;
     id: z.ZodString;
     needed_to_close: z.ZodString;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const DecRecordSchema: z.ZodObject<{
     schema_version: z.ZodLiteral<"1.0">;
     title: z.ZodString;
@@ -114,13 +136,19 @@ export declare const DecRecordSchema: z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"DEC">;
     id: z.ZodString;
     decision: z.ZodString;
@@ -129,7 +157,7 @@ export declare const DecRecordSchema: z.ZodObject<{
         rejected_because: z.ZodString;
     }, z.core.$strip>>>;
     consequences: z.ZodString;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const RecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schema_version: z.ZodLiteral<"1.0">;
     title: z.ZodString;
@@ -146,16 +174,22 @@ export declare const RecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"REQ">;
     id: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     schema_version: z.ZodLiteral<"1.0">;
     title: z.ZodString;
     status: z.ZodEnum<{
@@ -171,16 +205,22 @@ export declare const RecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"CONSTRAINT">;
     id: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     schema_version: z.ZodLiteral<"1.0">;
     title: z.ZodString;
     status: z.ZodEnum<{
@@ -196,17 +236,23 @@ export declare const RecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"ASSUMPTION">;
     id: z.ZodString;
     needed_to_close: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     schema_version: z.ZodLiteral<"1.0">;
     title: z.ZodString;
     status: z.ZodEnum<{
@@ -222,13 +268,19 @@ export declare const RecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"DEC">;
     id: z.ZodString;
     decision: z.ZodString;
@@ -237,7 +289,7 @@ export declare const RecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         rejected_because: z.ZodString;
     }, z.core.$strip>>>;
     consequences: z.ZodString;
-}, z.core.$strip>], "type">;
+}, z.core.$strict>], "type">;
 export type ReqRecord = z.infer<typeof ReqRecordSchema>;
 export type ConstraintRecord = z.infer<typeof ConstraintRecordSchema>;
 export type AssumptionRecord = z.infer<typeof AssumptionRecordSchema>;
@@ -251,15 +303,21 @@ export declare const AddRecordInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     links: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"REQ">;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     title: z.ZodString;
     owner: z.ZodOptional<z.ZodString>;
     change_authority: z.ZodOptional<z.ZodString>;
@@ -267,15 +325,21 @@ export declare const AddRecordInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     links: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"CONSTRAINT">;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     title: z.ZodString;
     owner: z.ZodOptional<z.ZodString>;
     change_authority: z.ZodOptional<z.ZodString>;
@@ -283,16 +347,22 @@ export declare const AddRecordInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     links: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"ASSUMPTION">;
     needed_to_close: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     title: z.ZodString;
     owner: z.ZodOptional<z.ZodString>;
     change_authority: z.ZodOptional<z.ZodString>;
@@ -300,13 +370,19 @@ export declare const AddRecordInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     links: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             constrains: "constrains";
+            decides: "decides";
             depends_on: "depends_on";
+            external: "external";
+            implements: "implements";
             refines: "refines";
             relates_to: "relates_to";
+            satisfies: "satisfies";
         }>;
         target: z.ZodString;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     type: z.ZodLiteral<"DEC">;
     decision: z.ZodString;
     alternatives_rejected: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -314,7 +390,7 @@ export declare const AddRecordInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         rejected_because: z.ZodString;
     }, z.core.$strip>>>;
     consequences: z.ZodString;
-}, z.core.$strip>], "type">;
+}, z.core.$strict>], "type">;
 export type AddRecordInput = z.infer<typeof AddRecordInputSchema>;
 export declare function sortRecords(records: DecisionRecord[]): DecisionRecord[];
 export declare function recordType(id: string): RecordType | undefined;

package/dist/register/register.d.ts

@@ -41,16 +41,22 @@ export declare const RegisterSchema: z.ZodObject<{
         links: z.ZodDefault<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
                 constrains: "constrains";
+                decides: "decides";
                 depends_on: "depends_on";
+                external: "external";
+                implements: "implements";
                 refines: "refines";
                 relates_to: "relates_to";
+                satisfies: "satisfies";
             }>;
             target: z.ZodString;
             rationale: z.ZodString;
         }, z.core.$strip>>>;
+        context: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         type: z.ZodLiteral<"REQ">;
         id: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         schema_version: z.ZodLiteral<"1.0">;
         title: z.ZodString;
         status: z.ZodEnum<{
@@ -66,16 +72,22 @@ export declare const RegisterSchema: z.ZodObject<{
         links: z.ZodDefault<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
                 constrains: "constrains";
+                decides: "decides";
                 depends_on: "depends_on";
+                external: "external";
+                implements: "implements";
                 refines: "refines";
                 relates_to: "relates_to";
+                satisfies: "satisfies";
             }>;
             target: z.ZodString;
             rationale: z.ZodString;
         }, z.core.$strip>>>;
+        context: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         type: z.ZodLiteral<"CONSTRAINT">;
         id: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         schema_version: z.ZodLiteral<"1.0">;
         title: z.ZodString;
         status: z.ZodEnum<{
@@ -91,17 +103,23 @@ export declare const RegisterSchema: z.ZodObject<{
         links: z.ZodDefault<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
                 constrains: "constrains";
+                decides: "decides";
                 depends_on: "depends_on";
+                external: "external";
+                implements: "implements";
                 refines: "refines";
                 relates_to: "relates_to";
+                satisfies: "satisfies";
             }>;
             target: z.ZodString;
             rationale: z.ZodString;
         }, z.core.$strip>>>;
+        context: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         type: z.ZodLiteral<"ASSUMPTION">;
         id: z.ZodString;
         needed_to_close: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         schema_version: z.ZodLiteral<"1.0">;
         title: z.ZodString;
         status: z.ZodEnum<{
@@ -117,13 +135,19 @@ export declare const RegisterSchema: z.ZodObject<{
         links: z.ZodDefault<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
                 constrains: "constrains";
+                decides: "decides";
                 depends_on: "depends_on";
+                external: "external";
+                implements: "implements";
                 refines: "refines";
                 relates_to: "relates_to";
+                satisfies: "satisfies";
             }>;
             target: z.ZodString;
             rationale: z.ZodString;
         }, z.core.$strip>>>;
+        context: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         type: z.ZodLiteral<"DEC">;
         id: z.ZodString;
         decision: z.ZodString;
@@ -132,7 +156,7 @@ export declare const RegisterSchema: z.ZodObject<{
             rejected_because: z.ZodString;
         }, z.core.$strip>>>;
         consequences: z.ZodString;
-    }, z.core.$strip>], "type">>;
+    }, z.core.$strict>], "type">>;
 }, z.core.$strip>;
 export declare function readRegister(filePath: string): Register;
 export declare function validateRegisterFile(filePath: string): void;

package/dist/v2/setup.d.ts

@@ -0,0 +1,27 @@
+/**
+ * v2 registration path, next to the v1 `server` export.
+ *
+ * Differences that matter for v2 (verified against @opencode/plugin 2.0.29):
+ * - tools are registered via `ctx.tool.transform` with a full input schema
+ *   (zod object) instead of a raw args shape;
+ * - the tool context has no `worktree`/`directory`, so the project root is
+ *   captured from `ctx.location.directory` at setup time and closed over;
+ * - the interview injection uses `ctx.session.hook('prompt')` and mutates the
+ *   outgoing prompt instead of appending to `command.execute.before` parts.
+ */
+interface V2TransformEditor {
+    add: (tool: unknown) => void;
+}
+export interface V2Context {
+    location: {
+        directory: string;
+    };
+    tool: {
+        transform: (callback: (editor: V2TransformEditor) => void) => Promise<unknown>;
+    };
+    session: {
+        hook: (name: string, callback: (event: unknown) => Promise<void> | void) => Promise<unknown>;
+    };
+}
+export declare function createV2Setup(): (ctx: V2Context) => Promise<void>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digi4care/omo-slim-decision-layer",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "description": "Git-native decision register for OpenCode: typed records (REQ/CONSTRAINT/ASSUMPTION/DEC), owner ratification and traceability, as a companion plugin for oh-my-opencode-slim",
   "type": "module",
   "license": "MIT",
@@ -64,6 +64,7 @@
   "devDependencies": {
     "@biomejs/biome": "2.5.15",
     "@opencode-ai/plugin": "1.18.35",
+    "@opencode/plugin": "^2.0.29",
     "bun-types": "^1.4.2",
     "typescript": "^7.0.2"
   },

package/schema/register.schema.json

@@ -74,10 +74,20 @@
                   "properties": {
                     "type": {
                       "type": "string",
-                      "enum": ["refines", "depends_on", "constrains", "relates_to"]
+                      "enum": [
+                        "refines",
+                        "depends_on",
+                        "constrains",
+                        "relates_to",
+                        "decides",
+                        "implements",
+                        "satisfies",
+                        "external"
+                      ]
                     },
                     "target": {
-                      "type": "string"
+                      "type": "string",
+                      "minLength": 1
                     },
                     "rationale": {
                       "type": "string",
@@ -88,6 +98,16 @@
                   "additionalProperties": false
                 }
               },
+              "context": {
+                "type": "string"
+              },
+              "meta": {
+                "type": "object",
+                "propertyNames": {
+                  "type": "string"
+                },
+                "additionalProperties": {}
+              },
               "type": {
                 "type": "string",
                 "const": "REQ"
@@ -150,10 +170,20 @@
                   "properties": {
                     "type": {
                       "type": "string",
-                      "enum": ["refines", "depends_on", "constrains", "relates_to"]
+                      "enum": [
+                        "refines",
+                        "depends_on",
+                        "constrains",
+                        "relates_to",
+                        "decides",
+                        "implements",
+                        "satisfies",
+                        "external"
+                      ]
                     },
                     "target": {
-                      "type": "string"
+                      "type": "string",
+                      "minLength": 1
                     },
                     "rationale": {
                       "type": "string",
@@ -164,6 +194,16 @@
                   "additionalProperties": false
                 }
               },
+              "context": {
+                "type": "string"
+              },
+              "meta": {
+                "type": "object",
+                "propertyNames": {
+                  "type": "string"
+                },
+                "additionalProperties": {}
+              },
               "type": {
                 "type": "string",
                 "const": "CONSTRAINT"
@@ -226,10 +266,20 @@
                   "properties": {
                     "type": {
                       "type": "string",
-                      "enum": ["refines", "depends_on", "constrains", "relates_to"]
+                      "enum": [
+                        "refines",
+                        "depends_on",
+                        "constrains",
+                        "relates_to",
+                        "decides",
+                        "implements",
+                        "satisfies",
+                        "external"
+                      ]
                     },
                     "target": {
-                      "type": "string"
+                      "type": "string",
+                      "minLength": 1
                     },
                     "rationale": {
                       "type": "string",
@@ -240,6 +290,16 @@
                   "additionalProperties": false
                 }
               },
+              "context": {
+                "type": "string"
+              },
+              "meta": {
+                "type": "object",
+                "propertyNames": {
+                  "type": "string"
+                },
+                "additionalProperties": {}
+              },
               "type": {
                 "type": "string",
                 "const": "ASSUMPTION"
@@ -307,10 +367,20 @@
                   "properties": {
                     "type": {
                       "type": "string",
-                      "enum": ["refines", "depends_on", "constrains", "relates_to"]
+                      "enum": [
+                        "refines",
+                        "depends_on",
+                        "constrains",
+                        "relates_to",
+                        "decides",
+                        "implements",
+                        "satisfies",
+                        "external"
+                      ]
                     },
                     "target": {
-                      "type": "string"
+                      "type": "string",
+                      "minLength": 1
                     },
                     "rationale": {
                       "type": "string",
@@ -321,6 +391,16 @@
                   "additionalProperties": false
                 }
               },
+              "context": {
+                "type": "string"
+              },
+              "meta": {
+                "type": "object",
+                "propertyNames": {
+                  "type": "string"
+                },
+                "additionalProperties": {}
+              },
               "type": {
                 "type": "string",
                 "const": "DEC"