chore: merge branch issue-28 with latest branding baseline

Author: Agent

README.md

@@ -172,6 +172,22 @@ Enough time for exactly one coffee and one suspiciously calm compile.
 ### Why does that long-running timer mention 42 minutes?
 
 It is only a metaphor for persistence.
+ 
+### Can Forkara help with non-code forks?
+
+Yes. If the fork has a clear owner and a clear next step, we can still model it in our glossary.
+
+### What is the difference between a Git fork and a dinner fork?
+
+A Git fork tracks history and intent; a dinner fork tracks dinner and intent is still optional.
+
+### Do you support pitchforks?
+
+They are useful for discussions that escalate quickly, and not required for code review.
+
+### Are sporks officially supported?
+
+Not yet. Sporks are in the roadmap, and we keep promises in the issue tracker before the kitchen.
 
 ---
 

apps/web/src/appSettings.test.ts

@@ -262,6 +262,20 @@ describe("environment panel defaults", () => {
   });
 });
 
+describe("upstream amnesia preference", () => {
+  it("defaults upstream hiding to off and persists the toggle as a local-only setting", () => {
+    const defaults = AppSettingsSchema.makeUnsafe({});
+    expect(defaults.hideUpstreamRepositoryInfo).toBe(false);
+
+    const decode = Schema.decodeSync(Schema.fromJsonString(AppSettingsSchema));
+    const decoded = decode(JSON.stringify({ hideUpstreamRepositoryInfo: true }));
+
+    expect(normalizeStoredAppSettings(decoded)).toMatchObject({
+      hideUpstreamRepositoryInfo: true,
+    });
+  });
+});
+
 describe("resolveAppModelSelection", () => {
   it("preserves saved custom model slugs instead of falling back to the default", () => {
     expect(

apps/web/src/appSettings.ts

@@ -224,6 +224,7 @@ export const AppSettingsSchema = Schema.Struct({
   environmentPanelDefaultOpen: Schema.Boolean.pipe(withDefaults(() => false)),
   showEnvironmentUsage: Schema.Boolean.pipe(withDefaults(() => true)),
   showEnvironmentRepository: Schema.Boolean.pipe(withDefaults(() => true)),
+  hideUpstreamRepositoryInfo: Schema.Boolean.pipe(withDefaults(() => false)),
   showEnvironmentPullRequest: Schema.Boolean.pipe(withDefaults(() => true)),
   showEnvironmentEditor: Schema.Boolean.pipe(withDefaults(() => true)),
   showEnvironmentRecap: Schema.Boolean.pipe(withDefaults(() => true)),

apps/web/src/components/ForkDenialStage.test.tsx

@@ -0,0 +1,18 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vitest";
+
+import { getForkDenialStages } from "../lib/forkDenial";
+import { ForkDenialStageList } from "./ForkDenialStage";
+
+describe("ForkDenialStage", () => {
+  it("renders every stage label in provided order", () => {
+    const stages = getForkDenialStages({ includeFinalForkState: true });
+    const markup = renderToStaticMarkup(<ForkDenialStageList stages={stages} />);
+    const indexes = stages.map((stage) => markup.indexOf(stage.label));
+
+    for (const index of indexes) {
+      expect(index).toBeGreaterThanOrEqual(0);
+    }
+    expect(indexes).toEqual([...indexes].sort((a, b) => a - b));
+  });
+});

apps/web/src/components/ForkDenialStage.tsx

@@ -0,0 +1,31 @@
+// FILE: ForkDenialStage.tsx
+// Purpose: Tiny renderer for fork-denial stage copy.
+// Layer: UI primitives
+
+import { type ForkDenialStage, getForkDenialStages } from "../lib/forkDenial";
+
+export interface ForkDenialStageChipProps {
+  stage: ForkDenialStage;
+}
+
+export function ForkDenialStageChip({ stage }: ForkDenialStageChipProps) {
+  return <span>{stage.label}</span>;
+}
+
+export interface ForkDenialStageListProps {
+  stages: readonly ForkDenialStage[];
+}
+
+export function ForkDenialStageList({ stages }: ForkDenialStageListProps) {
+  return (
+    <ul>
+      {stages.map((stage) => (
+        <li key={stage.id}>
+          <ForkDenialStageChip stage={stage} />
+        </li>
+      ))}
+    </ul>
+  );
+}
+
+export { getForkDenialStages };

apps/web/src/components/chat/ComposerPendingApprovalPanel.browser.tsx

@@ -93,6 +93,34 @@ describe("ComposerPendingApprovalPanel", () => {
     }
   });
 
+  it("renders license-changer parody copy for permission requests", async () => {
+    const mounted = await mountApprovalPanel({
+      approval: makeApproval({
+        requestKind: "permissions",
+        detail: "Request to adjust LICENSE terms",
+        permissionProfile: { license: { file: "LICENSE", readable: true }, copyrightOwner: "forkara-team" },
+      }),
+    });
+
+    try {
+      await expect.element(
+        page.getByText(
+          "License Changer check: confirm legal ownership before proceeding",
+        ),
+      ).toBeInTheDocument();
+      await expect.element(page.getByRole("link", { name: /Read current LICENSE/u })).toBeInTheDocument();
+      await expect
+        .element(
+          page.getByText(
+            "Changing license terms is not a cosmetic toggle. Verify ownership and repository policy before allowing",
+          ),
+        )
+        .toBeInTheDocument();
+    } finally {
+      await mounted.cleanup();
+    }
+  });
+
   it("hides session approval when the provider cannot persist it", async () => {
     const mounted = await mountApprovalPanel({
       approval: makeApproval({ sessionApprovalAvailable: false }),

apps/web/src/components/chat/ComposerPendingApprovalPanel.tsx

@@ -76,13 +76,32 @@ const KIND_PROMPT: Record<PendingApproval["requestKind"], string> = {
   permissions: "Grant these permissions?",
 };
 
+const LICENSE_REFERENCE_URL = "https://github.com/redxzeta/forkara/blob/built-from-scratch/LICENSE";
+
+const LICENSE_RELATED_KEYWORDS = ["license", "copyright", "copyright owner", "license_file", "license file"];
+
+function hasLicenseSignals(input: { detail?: string; permissionProfile?: Record<string, unknown> }): boolean {
+  const detail = input.detail?.toLowerCase() ?? "";
+  const profile = input.permissionProfile;
+  if (!detail && !profile) {
+    return false;
+  }
+  if (detail && LICENSE_RELATED_KEYWORDS.some((keyword) => detail.includes(keyword))) {
+    return true;
+  }
+  const profileText = profile ? JSON.stringify(profile).toLowerCase() : "";
+  return LICENSE_RELATED_KEYWORDS.some((keyword) => profileText.includes(keyword));
+}
+
 export const ComposerPendingApprovalPanel = function ComposerPendingApprovalPanel({
   approval,
   pendingCount,
   isResponding,
   onRespond,
 }: ComposerPendingApprovalPanelProps) {
   const parsed = parseApprovalDetail(approval.detail);
+  const licenseProfileHint =
+    approval.requestKind === "permissions" && hasLicenseSignals({ detail: approval.detail, permissionProfile: approval.permissionProfile });
   const requestId = approval.requestId;
   const actions =
     approval.sessionApprovalAvailable === false
@@ -116,7 +135,9 @@ export const ComposerPendingApprovalPanel = function ComposerPendingApprovalPane
     >
       <div className="flex items-start justify-between gap-3">
         <p className="min-w-0 text-[13px] font-medium leading-snug text-foreground/90">
-          {KIND_PROMPT[approval.requestKind]}
+          {licenseProfileHint
+            ? "License Changer check: confirm legal ownership before proceeding"
+            : KIND_PROMPT[approval.requestKind]}
           {parsed.tool ? (
             <span className="ml-1.5 text-[11px] font-normal text-muted-foreground/50">
               {parsed.tool}
@@ -132,6 +153,7 @@ export const ComposerPendingApprovalPanel = function ComposerPendingApprovalPane
       <ApprovalDetail
         parsed={parsed}
         {...(approval.permissionProfile ? { permissionProfile: approval.permissionProfile } : {})}
+        showLicenseChangerCopy={licenseProfileHint}
       />
       <div className="mt-2.5 space-y-0.5">
         {actions.map((action, index) => (
@@ -160,11 +182,38 @@ export const ComposerPendingApprovalPanel = function ComposerPendingApprovalPane
 function ApprovalDetail({
   parsed,
   permissionProfile,
+  showLicenseChangerCopy,
 }: {
   parsed: ParsedApproval;
   permissionProfile?: Record<string, unknown>;
+  showLicenseChangerCopy?: boolean;
 }) {
   if (permissionProfile) {
+    if (showLicenseChangerCopy) {
+      return (
+        <div className="mt-2">
+          <p className="mb-1.5 text-[11.5px] leading-snug text-muted-foreground/70">
+            Changing license terms is not a cosmetic toggle. Verify ownership and repository policy before allowing
+            this, and keep the existing LICENSE as the source of truth.
+          </p>
+          <a
+            href={LICENSE_REFERENCE_URL}
+            target="_blank"
+            rel="noreferrer"
+            className="mb-1.5 inline-flex text-xs text-[var(--color-text-primary)] underline"
+          >
+            Read current LICENSE
+          </a>
+          <pre
+            className="max-h-36 overflow-auto whitespace-pre-wrap break-words rounded-md bg-[var(--color-background-elevated-secondary)] px-2.5 py-2 font-mono text-[11px] leading-relaxed text-foreground/85"
+            title="Requested permission profile"
+          >
+            <code>{JSON.stringify(permissionProfile, null, 2)}</code>
+          </pre>
+        </div>
+      );
+    }
+
     return (
       <div className="mt-2">
         {parsed.fallback ? (

apps/web/src/components/chat/environment/EnvironmentPanel.logic.test.ts

@@ -1,5 +1,7 @@
+import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it } from "vitest";
 
+import { getRepositoryLabel, UPSTREAM_AMNESIA_HINT, UPSTREAM_AMNESIA_LABEL } from "./EnvironmentPanel";
 import { shouldShowStudioFolderRow } from "./EnvironmentPanel.logic";
 
 describe("shouldShowStudioFolderRow", () => {
@@ -37,3 +39,30 @@ describe("shouldShowStudioFolderRow", () => {
     ).toBe(false);
   });
 });
+
+describe("getRepositoryLabel", () => {
+  it("shows the upstream repository when amnesia is disabled", () => {
+    const markup = renderToStaticMarkup(
+      getRepositoryLabel({
+        githubRepository: { nameWithOwner: "openai/codex", url: "https://github.com/openai/codex" },
+        hideUpstreamRepositoryInfo: false,
+      }),
+    );
+
+    expect(markup).toContain("openai/codex");
+    expect(markup).not.toContain(UPSTREAM_AMNESIA_LABEL);
+  });
+
+  it("hides upstream identity with amnesia messaging when enabled", () => {
+    const markup = renderToStaticMarkup(
+      getRepositoryLabel({
+        githubRepository: { nameWithOwner: "openai/codex", url: "https://github.com/openai/codex" },
+        hideUpstreamRepositoryInfo: true,
+      }),
+    );
+
+    expect(markup).toContain(UPSTREAM_AMNESIA_LABEL);
+    expect(markup).toContain(UPSTREAM_AMNESIA_HINT);
+    expect(markup).not.toContain("openai/codex");
+  });
+});

apps/web/src/components/chat/environment/EnvironmentPanel.tsx

@@ -21,6 +21,7 @@ import type {
   ThreadMarkerId,
 } from "@synara/contracts";
 import { useNavigate } from "@tanstack/react-router";
+import { type ReactNode } from "react";
 
 import { useAppSettings } from "~/appSettings";
 import { SETTINGS_TARGETS } from "~/settingsNavigation";
@@ -73,6 +74,31 @@ export const ENVIRONMENT_DOCKED_CONTENT_INSET_PX = 312;
 
 const ENVIRONMENT_PANEL_OVERLAY_WRAPPER_CLASS_NAME =
   "pointer-events-none absolute inset-y-0 right-0 z-20 flex flex-col p-3";
+export const UPSTREAM_AMNESIA_LABEL = "Upstream information hidden";
+export const UPSTREAM_AMNESIA_HINT = "Upstream successfully forgotten. Git remembers.";
+
+export function getRepositoryLabel(input: {
+  githubRepository: {
+    readonly nameWithOwner: string;
+    readonly url: string;
+  } | null;
+  hideUpstreamRepositoryInfo: boolean;
+}): ReactNode {
+  if (!input.hideUpstreamRepositoryInfo) {
+    return (
+      <span className="truncate">{input.githubRepository?.nameWithOwner ?? "Unknown repository"}</span>
+    );
+  }
+
+  return (
+    <span className="flex min-w-0 flex-col gap-0.5">
+      <span className="truncate text-muted-foreground">{UPSTREAM_AMNESIA_LABEL}</span>
+      <span className="truncate text-[length:var(--app-font-size-ui-xs,10px)] text-muted-foreground/80">
+        {UPSTREAM_AMNESIA_HINT}
+      </span>
+    </span>
+  );
+}
 
 export interface EnvironmentPanelProps {
   /** Drives the slide-in/out transition; the panel stays mounted so CSS can interpolate. */
@@ -387,12 +413,26 @@ export function EnvironmentPanel({
         <EnvironmentLabeledSection label="Repository">
           <EnvironmentRow
             icon={<GitHubIcon className={ENVIRONMENT_ROW_ICON_CLASS_NAME} aria-hidden />}
-            label={<span className="truncate">{githubRepository.nameWithOwner}</span>}
-            trailing={<ArrowUpRightIcon className={ENVIRONMENT_ROW_ICON_CLASS_NAME} aria-hidden />}
-            onClick={() => {
-              onOpenGithubRepository(githubRepository.url);
-              onClose();
-            }}
+            label={getRepositoryLabel({
+              githubRepository,
+              hideUpstreamRepositoryInfo: settings.hideUpstreamRepositoryInfo,
+            })}
+            trailing={
+              !settings.hideUpstreamRepositoryInfo ? (
+                <ArrowUpRightIcon className={ENVIRONMENT_ROW_ICON_CLASS_NAME} aria-hidden />
+              ) : null
+            }
+            {...(!settings.hideUpstreamRepositoryInfo
+              ? {
+                  onClick: () => {
+                    onOpenGithubRepository(githubRepository.url);
+                    onClose();
+                  },
+                }
+              : {
+                  "aria-label": "Upstream repository identity is hidden",
+                  title: "Upstream repository identity is hidden",
+                })}
           />
         </EnvironmentLabeledSection>
       ) : null}

apps/web/src/lib/forkDenial.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+
+import { FORK_DENIAL_FINAL_STAGE, FORK_DENIAL_STAGES, getForkDenialStages, isFinalForkDenialStage } from "./forkDenial";
+
+describe("forkDenial", () => {
+  it("defines the escalation order for fork-denial copy", () => {
+    expect(FORK_DENIAL_STAGES.map((stage) => stage.label)).toEqual([
+      "Not a fork",
+      "Technically not a fork",
+      "Mostly not a fork",
+      "Forks are normal",
+      "The fork isn't that bad",
+    ]);
+    expect(FORK_DENIAL_STAGES.map((stage) => stage.id)).toEqual([
+      "not-a-fork",
+      "technically-not-a-fork",
+      "mostly-not-a-fork",
+      "forks-are-normal",
+      "fork-isnt-that-bad",
+    ]);
+  });
+
+  it("supports an optional final fork state", () => {
+    const withFinal = getForkDenialStages({ includeFinalForkState: true });
+
+    expect(withFinal).toHaveLength(6);
+    expect(withFinal).toContain(FORK_DENIAL_FINAL_STAGE);
+    expect(isFinalForkDenialStage(withFinal[5]!)).toBe(true);
+  });
+
+  it("keeps default stages limited to the core satire ladder", () => {
+    const core = getForkDenialStages();
+    expect(core).toHaveLength(5);
+    expect(core).toEqual(FORK_DENIAL_STAGES);
+  });
+});