@basou/core 0.38.0 → 0.39.0

package/dist/index.d.ts

@@ -107,21 +107,12 @@ declare function removeStopHook(settings: unknown): StopHookRemoval;
 declare function findBasouStopHookCommand(settings: unknown): string | null;
 
 /**
- * Schema for `.basou/manifest.yaml`. The minimal manifest carries
- * schema_version, basou_version, workspace metadata, project info, enabled
- * capabilities, approval policy, adapter config, and git policy. The
- * `adapters."claude-code"` key uses a hyphen; downstream code accesses it
- * via bracket notation.
- *
- * Every object here is `looseObject` (NOT the default strip), so unknown keys
- * at every level survive parse. The manifest is the declarative source of truth
- * and is git-tracked and read-modify-written by `basou project` commands; with
- * the default strip, a field this basou does not recognize — a newer version's
- * additive field, a future adapter under `adapters`, a hand-added key — would be
- * silently dropped on the next write. Preserving them keeps basou from destroying
- * config it does not understand (forward-compatible), while known fields are still
- * fully type-checked and validated. {@link unknownManifestKeys} surfaces the
- * unrecognized top-level keys so preservation is not silent.
+ * The manifest, plus one guard the loose object cannot express: a TOP-LEVEL
+ * `confidential` is refused. It belongs under `policies`, and because the
+ * object is loose, a stray top-level spelling would otherwise parse fine and be
+ * silently ignored — an operator would believe the workspace is protected while
+ * the face is still written. A safety key that is not honoured must fail
+ * loudly, not quietly.
  */
 declare const ManifestSchema: z.ZodObject<{
     schema_version: z.ZodString;
@@ -197,6 +188,12 @@ declare const ManifestSchema: z.ZodObject<{
             self: "self";
         }>>;
     }, z.core.$loose>>>;
+    channels: z.ZodOptional<z.ZodObject<{
+        codex: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    policies: z.ZodOptional<z.ZodObject<{
+        confidential: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 /** Inferred runtime type for {@link ManifestSchema}. */
 type Manifest = z.infer<typeof ManifestSchema>;

package/dist/index.js

@@ -1782,7 +1782,35 @@ var WorkspaceMetaSchema = z4.looseObject({
    */
   view: SourceRootSchema.optional()
 });
-var ManifestSchema = z4.looseObject({
+var ChannelsSchema = z4.looseObject({
+  /**
+   * Render this workspace's orientation into `~/.codex/AGENTS.md` on `basou
+   * refresh` / `basou run codex`. A boolean today; if a face ever needs
+   * per-block control this widens to `boolean | object`, which existing
+   * manifests keep parsing — so the boolean does not foreclose that.
+   */
+  codex: z4.boolean().optional().meta({
+    description: "Opt in to rendering this workspace's orientation into the user-global ~/.codex/AGENTS.md on `basou refresh` and `basou run codex`. Off when absent: that file is auto-loaded by Codex for every project on the machine, so nothing is written there unless the workspace says so."
+  })
+});
+var PoliciesSchema = z4.looseObject({
+  /**
+   * This workspace's provenance must not persist where another workspace's
+   * tool reads it. That is the GOAL the key states; what it gates today is one
+   * thing: rendering the orientation into the user-global `~/.codex/AGENTS.md`
+   * (`basou refresh` / `basou run codex`) — never, regardless of `channels`, so
+   * a confidential workspace cannot be re-enabled by a second declaration in
+   * the same file. It does not yet govern `basou protocol sync` (a global
+   * render, not a per-workspace one), and it gates writing only: it cannot keep
+   * another workspace's block out of this workspace's tool (see `basou channel
+   * clear`). Stated as a goal rather than as "never write" so that a transient
+   * render removed before anyone else can read it remains permissible.
+   */
+  confidential: z4.boolean().optional().meta({
+    description: "This workspace's provenance must not persist where another workspace's tool reads it. Today this means its orientation is never rendered into the user-global ~/.codex/AGENTS.md by `basou refresh` or `basou run codex`, regardless of `channels`. It does not yet govern `basou protocol sync`, and it gates writing only \u2014 it cannot keep another workspace's block out of this workspace's tool."
+  })
+});
+var ManifestObjectSchema = z4.looseObject({
   schema_version: SchemaVersionSchema,
   // Same forward-compatible format gate as schema_version (accept 0.x.y, gate a
   // higher major with an upgrade error) rather than a hard literal. `basou_version`
@@ -1796,9 +1824,20 @@ var ManifestSchema = z4.looseObject({
   adapters: AdaptersSchema,
   git: GitConfigSchema,
   import: ImportConfigSchema.optional(),
-  repos: z4.array(RepoEntrySchema).min(1).optional()
+  repos: z4.array(RepoEntrySchema).min(1).optional(),
+  channels: ChannelsSchema.optional(),
+  policies: PoliciesSchema.optional()
+});
+var ManifestSchema = ManifestObjectSchema.superRefine((manifest, ctx) => {
+  if ("confidential" in manifest) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["confidential"],
+      message: "`confidential` is declared under `policies` (policies.confidential: true). A top-level `confidential` is not honoured, so it is rejected rather than ignored."
+    });
+  }
 });
-var KNOWN_TOP_LEVEL_KEYS = new Set(Object.keys(ManifestSchema.shape));
+var KNOWN_TOP_LEVEL_KEYS = new Set(Object.keys(ManifestObjectSchema.shape));
 function unknownManifestKeys(manifest) {
   return Object.keys(manifest).filter((k) => !KNOWN_TOP_LEVEL_KEYS.has(k)).sort();
 }