@@ -0,0 +1,16 @@
+---
+"@objectstack/spec": patch
+---
+
+fix(spec): the `manifest.namespace` refusal now names the leading-letter rule its pattern enforces
+
+Clause-②: no
+
+`manifest.namespace` is enforced by `^[a-z][a-z0-9_]{1,19}$`, so its FIRST character must be a lowercase letter. Its refusal sentence and its TSDoc `Rules:` line stated only the length and the charset, so `1leave` and `_leave` satisfied every clause an author was shown and were still refused, by a sentence that could not say why.
+
+- **The refusal sentence** is now `Namespace must be 2-20 chars, start with a lowercase letter, and contain only lowercase letters, digits and underscores`. It was `Namespace must be 2-20 chars, lowercase alphanumeric + underscore`.
+- **The same sentence on the publish payload.** `PackageSchema.namespace` and `CreatePackageRequestSchema.namespace` (`marketplace/package.zod.ts`, and through them the scaffold-only `TemplateManifestSchema.namespace`) carried a byte-identical copy of the old sentence and carry the new one. A new pin holds all four fields to `manifest.namespace`'s sentence, not only to its verdicts.
+- **The TSDoc `Rules:` line** now reads `2-20 characters, starting with a lowercase letter; lowercase letters, digits, and underscores only`.
+- **Doors that surface the sentence verbatim** carry the new text with no change of their own. For example, `duplicatePackage`'s refusal of an explicit `targetNamespace` reads the declaration's message, so its rule clause now names the leading letter too.
+
+The accept set is unchanged: the pattern is byte-identical, and every value that parsed before still parses. Only the text shown on a refusal changes. A consumer that matched the old sentence verbatim needs to match the new one.
@@ -675,3 +675,44 @@ describe('manifest.id — reverse-domain identifier', () => {
     }
   });
 });
+
+describe('manifest.namespace — the refusal states the rule the regex enforces', () => {
+  // The pattern is `^[a-z][a-z0-9_]{1,19}$`: the FIRST character must be a
+  // lowercase letter. A refusal sentence that only says "2-20 chars, lowercase
+  // alphanumeric + underscore" is satisfied by `1leave` and `_leave`, so the
+  // author it refuses is told a rule they already follow. The sentence is also
+  // surfaced verbatim by other doors (e.g. `duplicatePackage`'s explicit
+  // `targetNamespace`), so it has to carry the whole rule on its own.
+  const namespaceRefusal = (value: string) => {
+    const r = ManifestSchema.shape.namespace.safeParse(value);
+    expect(r.success, `'${value}' must be refused`).toBe(false);
+    const issues = r.success ? [] : r.error.issues;
+    expect(issues).toHaveLength(1);
+    expect(issues[0].code).toBe('invalid_format');
+    return issues[0].message;
+  };
+
+  it.each([
+    ['1leave', 'a leading digit'],
+    ['_leave', 'a leading underscore'],
+  ])('refuses %s (%s) with a sentence naming the leading-letter rule', (value) => {
+    expect(namespaceRefusal(value)).toMatch(/start with a lowercase letter/);
+  });
+
+  it('the same sentence still names the length and the charset', () => {
+    const msg = namespaceRefusal('1leave');
+    expect(msg).toMatch(/2-20 chars/);
+    expect(msg).toMatch(/lowercase letters, digits and underscores/);
+  });
+
+  it.each(['leave', 'crm', 'my_app_2', 'a1', 'abcdefghijklmnopqrst'])(
+    'lit control — %s still parses',
+    (value) => {
+      expect(ManifestSchema.shape.namespace.safeParse(value).success).toBe(true);
+      expect(
+        ManifestSchema.safeParse({ id: 'com.example.leave', version: '1.0.0', type: 'app', name: 'X', namespace: value })
+          .success,
+      ).toBe(true);
+    },
+  );
+});
@@ -379,15 +379,16 @@ export const ManifestSchema = strictObject({
    * multiple packages installed in the same database cannot collide.
    *
    * Rules:
-   * - 2-20 characters, lowercase letters, digits, and underscores only.
+   * - 2-20 characters, starting with a lowercase letter; lowercase letters,
+   *   digits, and underscores only (`1leave` and `_leave` are refused).
    * - Must be unique within a running instance.
    * - Platform-reserved namespaces: "base", "system", "sys".
    * - Object names starting with `sys_` are reserved for the platform
    *   and exempt from the namespace-prefix check (apps may reference
    *   them but never define them).
    */
   namespace: z.string()
-    .regex(/^[a-z][a-z0-9_]{1,19}$/, 'Namespace must be 2-20 chars, lowercase alphanumeric + underscore')
+    .regex(/^[a-z][a-z0-9_]{1,19}$/, 'Namespace must be 2-20 chars, start with a lowercase letter, and contain only lowercase letters, digits and underscores')
     .optional()
     .describe('Short namespace identifier; also the mandatory prefix of every object name (e.g. "todo" → object names "todo_task", "todo_project")'),
 
 
@@ -97,7 +97,7 @@ describe('PackageSchema.namespace (ADR-0048 addendum Phase A1)', () => {
     expect(issues[0].code).toBe('invalid_format');
     expect(issues[0].path).toEqual(['namespace']);
     expect(issues[0].message).toBe(
-      'Namespace must be 2-20 chars, lowercase alphanumeric + underscore',
+      'Namespace must be 2-20 chars, start with a lowercase letter, and contain only lowercase letters, digits and underscores',
     );
   });
 
@@ -157,6 +157,23 @@ describe('two gates, one vocabulary (§A.7)', () => {
     )).toEqual([]);
   });
 
+  it('every field refuses with the SAME sentence, so both sides prescribe the same rule', () => {
+    // The verdict table above cannot see the prose: two declarations can agree
+    // on every value and still tell a refused author two different rules. Read
+    // the sentence off each field for a value only the leading-letter clause
+    // refuses, and hold all four to manifest.namespace's.
+    const sentenceOf = (field: { safeParse: (v: unknown) => { success: boolean; error?: { issues: Array<{ message: string }> } } }) => {
+      const r = field.safeParse('1leave');
+      expect(r.success).toBe(false);
+      return r.error?.issues[0]?.message;
+    };
+    const manifestSentence = sentenceOf(ManifestSchema.shape.namespace);
+    expect(manifestSentence).toMatch(/start with a lowercase letter/);
+    expect(sentenceOf(PackageSchema.shape.namespace)).toBe(manifestSentence);
+    expect(sentenceOf(CreatePackageRequestSchema.shape.namespace)).toBe(manifestSentence);
+    expect(sentenceOf(TemplateManifestSchema.shape.namespace)).toBe(manifestSentence);
+  });
+
   it('every field is optional, so "absent" means the same thing on all sides', () => {
     expect(ManifestSchema.shape.namespace.safeParse(undefined).success).toBe(true);
     expect(PackageSchema.shape.namespace.safeParse(undefined).success).toBe(true);
@@ -208,7 +225,7 @@ describe('TemplateManifestSchema declares namespace as a scaffold-only extra (#6
     expect(issues[0].code).toBe('invalid_format');
     expect(issues[0].path).toEqual(['namespace']);
     expect(issues[0].message).toBe(
-      'Namespace must be 2-20 chars, lowercase alphanumeric + underscore',
+      'Namespace must be 2-20 chars, start with a lowercase letter, and contain only lowercase letters, digits and underscores',
     );
   });
 
 
@@ -195,11 +195,12 @@ export const PackageSchema = lazySchema(() => z.object({
    */
   namespace: z
     .string()
-    // Kept byte-identical to `ManifestSchema.shape.namespace`'s pattern; the
-    // two are pinned against each other by `package-namespace.test.ts` so the
-    // publish payload and the manifest cannot drift into disagreeing about
-    // what a namespace is (addendum §A.7 "two gates, one vocabulary").
-    .regex(/^[a-z][a-z0-9_]{1,19}$/, 'Namespace must be 2-20 chars, lowercase alphanumeric + underscore')
+    // Kept byte-identical to `ManifestSchema.shape.namespace`'s pattern and
+    // refusal sentence; the two are pinned against each other by
+    // `package-namespace.test.ts` so the publish payload and the manifest
+    // cannot drift into disagreeing about what a namespace is, or into
+    // prescribing it differently (addendum §A.7 "two gates, one vocabulary").
+    .regex(/^[a-z][a-z0-9_]{1,19}$/, 'Namespace must be 2-20 chars, start with a lowercase letter, and contain only lowercase letters, digits and underscores')
     .optional()
     .describe('Metadata namespace claimed by the package (mirrors manifest.namespace; e.g. "crm" → object names "crm_account")'),